
bin/main.elf:     file format elf32-littlearm

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00001268  00000000  00000000  00010000  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .text.arm_Init 00000138  00001268  00001268  00011268  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .text._start  00000048  000013a0  000013a0  000113a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  3 .text.nmi_ISR 00000020  000013e8  000013e8  000113e8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  4 .text.hardFault_ISR 00000050  00001408  00001408  00011408  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  5 .text.memManage_ISR 00000020  00001458  00001458  00011458  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  6 .text.busFault_ISR 00000020  00001478  00001478  00011478  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  7 .text.usageFault_ISR 00000020  00001498  00001498  00011498  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  8 .text.svc_ISR 00000020  000014b8  000014b8  000114b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  9 .text.debugMon_ISR 00000020  000014d8  000014d8  000114d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 10 .text.pendSV_ISR 00000020  000014f8  000014f8  000114f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 11 .text.wdt_ISR 00000020  00001518  00001518  00011518  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 12 .text.timer0_ISR 00000020  00001538  00001538  00011538  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 13 .text.timer1_ISR 00000020  00001558  00001558  00011558  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 14 .text.timer2_ISR 00000020  00001578  00001578  00011578  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 15 .text.timer3_ISR 00000020  00001598  00001598  00011598  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 16 .text.uart1_ISR 00000020  000015b8  000015b8  000115b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 17 .text.uart2_ISR 00000020  000015d8  000015d8  000115d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 18 .text.uart3_ISR 00000020  000015f8  000015f8  000115f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 19 .text.pwm_ISR 00000020  00001618  00001618  00011618  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 20 .text.i2c0_ISR 00000020  00001638  00001638  00011638  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 21 .text.i2c1_ISR 00000020  00001658  00001658  00011658  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 22 .text.i2c2_ISR 00000020  00001678  00001678  00011678  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 23 .text.spi_ISR 00000020  00001698  00001698  00011698  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 24 .text.ssp0_ISR 00000020  000016b8  000016b8  000116b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 25 .text.ssp1_ISR 00000020  000016d8  000016d8  000116d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 26 .text.pll0_ISR 00000020  000016f8  000016f8  000116f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 27 .text.rtc_ISR 00000020  00001718  00001718  00011718  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 28 .text.eint0_ISR 00000020  00001738  00001738  00011738  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 29 .text.eint1_ISR 00000020  00001758  00001758  00011758  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 30 .text.eint2_ISR 00000020  00001778  00001778  00011778  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 31 .text.eint3_ISR 00000020  00001798  00001798  00011798  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 32 .text.adc_ISR 00000020  000017b8  000017b8  000117b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 33 .text.bod_ISR 00000020  000017d8  000017d8  000117d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 34 .text.usbHost_ISR 00000020  000017f8  000017f8  000117f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 35 .text.can_ISR 00000020  00001818  00001818  00011818  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 36 .text.dma_ISR 00000020  00001838  00001838  00011838  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 37 .text.i2s_ISR 00000020  00001858  00001858  00011858  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 38 .text.enet_ISR 00000020  00001878  00001878  00011878  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 39 .text.rit_ISR 00000020  00001898  00001898  00011898  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 40 .text.mcpwm_ISR 00000020  000018b8  000018b8  000118b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 41 .text.qei_ISR 00000020  000018d8  000018d8  000118d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 42 .text.pll1_ISR 00000020  000018f8  000018f8  000118f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 43 .text.usbAct_ISR 00000020  00001918  00001918  00011918  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 44 .text.canAct_ISR 00000020  00001938  00001938  00011938  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 45 .text.uart4_ISR 00000020  00001958  00001958  00011958  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 46 .text.ssp2_ISR 00000020  00001978  00001978  00011978  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 47 .text.lcd_ISR 00000020  00001998  00001998  00011998  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 48 .text.gpio_ISR 00000020  000019b8  000019b8  000119b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 49 .text.pwm0_ISR 00000020  000019d8  000019d8  000119d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 50 .text.eeprom_ISR 00000020  000019f8  000019f8  000119f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 51 .text.nvic_setPendingIRQ 0000001a  00001a18  00001a18  00011a18  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 52 .text.nvic_enableIRQ 00000004  00001a32  00001a32  00011a32  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 53 .text.nvic_clearPendingIRQ 00000018  00001a38  00001a38  00011a38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 54 .text.nvic_setPriority 00000044  00001a50  00001a50  00011a50  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 55 .text.nvic_SetIntHandler 0000000c  00001a94  00001a94  00011a94  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 56 .text.systime_Init 0000005c  00001aa0  00001aa0  00011aa0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 57 .text.systime_SetIntHandler 00000014  00001afc  00001afc  00011afc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 58 .text.sysTick_ISR 00000064  00001b10  00001b10  00011b10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 59 .text.delay   00000006  00001b74  00001b74  00011b74  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 60 .text.uart0_SetBaudrate 000000ec  00001b80  00001b80  00011b80  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 61 .text.uart0_Init 000000b0  00001c6c  00001c6c  00011c6c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 62 .text.uart0_GetChar 00000044  00001d1c  00001d1c  00011d1c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 63 .text.uart0_PutChar 00000068  00001d60  00001d60  00011d60  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 64 .text.uart0_BasicPutChar 0000001c  00001dc8  00001dc8  00011dc8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 65 .text.uart0_ISR 000000b4  00001de4  00001de4  00011de4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 66 .text.showVicError 00000078  00001e98  00001e98  00011e98  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 67 .text.startup.main 000000c0  00001f10  00001f10  00011f10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 68 .text.onKeyDown 00000034  00001fd0  00001fd0  00011fd0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 69 .text.onKeyPress 00000018  00002004  00002004  00012004  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 70 .text.onKeyUp 00000018  0000201c  0000201c  0001201c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 71 .text.relay_Init 00000028  00002034  00002034  00012034  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 72 .text.relay_Set 00000030  0000205c  0000205c  0001205c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 73 .text.relay_Tick 00000068  0000208c  0000208c  0001208c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 74 .text.app_Init 0000012c  000020f4  000020f4  000120f4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 75 .text.app_Tick 000000a4  00002220  00002220  00012220  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 76 .text.app_Process 000000c8  000022c4  000022c4  000122c4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 77 .text.prompt_ClearTicks 00000010  0000238c  0000238c  0001238c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 78 .text.prompt_STS 0000006c  0000239c  0000239c  0001239c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 79 .text.prompt_Dump 0000008a  00002408  00002408  00012408  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 80 .text.prompt_Beep 0000001a  00002492  00002492  00012492  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 81 .text.prompt_Relay 00000068  000024ac  000024ac  000124ac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 82 .text.prompt_Process 00000088  00002514  00002514  00012514  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 83 .text.print_putchar 00000074  0000259c  0000259c  0001259c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 84 .text.print_fill 0000001a  00002610  00002610  00012610  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 85 .text.print_int 00000058  0000262a  0000262a  0001262a  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 86 .text.print_long 0000004e  00002682  00002682  00012682  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 87 .text.print_float 000000b4  000026d0  000026d0  000126d0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 88 .text.rprintf_RegisterDev 00000030  00002784  00002784  00012784  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 89 .text.lputchar_RegisterDev 0000000c  000027b4  000027b4  000127b4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 90 .text.ldebug_RegisterDev 0000000c  000027c0  000027c0  000127c0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 91 .text.lgetchar_RegisterDev 0000000c  000027cc  000027cc  000127cc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 92 .text.doprint 00000378  000027d8  000027d8  000127d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 93 .text.lgetchar 0000000c  00002b50  00002b50  00012b50  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 94 .text.rprintf 0000002a  00002b5c  00002b5c  00012b5c  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 95 .text.buffer_Init 0000000c  00002b86  00002b86  00012b86  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 96 .text.buffer_GetFromFront 00000044  00002b92  00002b92  00012b92  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 97 .text.buffer_AddToEnd 0000003a  00002bd6  00002bd6  00012bd6  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 98 .text.buffer_IsEmpty 0000000c  00002c10  00002c10  00012c10  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 99 .text.put_dump16 00000094  00002c1c  00002c1c  00012c1c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
100 .text.xatoi   000000a8  00002cb0  00002cb0  00012cb0  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
101 .text.ledError_Init 00000018  00002d58  00002d58  00012d58  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
102 .text.ledError_Tick 00000090  00002d70  00002d70  00012d70  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
103 .text.gKey_Init 00000024  00002e00  00002e00  00012e00  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
104 .text.gKey_Tick 00000014  00002e24  00002e24  00012e24  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
105 .text.gKey_Process 000000a8  00002e38  00002e38  00012e38  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
106 .text.beep_SetType 000000a0  00002ee0  00002ee0  00012ee0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
107 .text.beep_Init 0000002c  00002f80  00002f80  00012f80  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
108 .text.beep_Play 00000024  00002fac  00002fac  00012fac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
109 .text.beep_Tick 0000008c  00002fd0  00002fd0  00012fd0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
110 .text.cli_GetLine 000000f4  0000305c  0000305c  0001305c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
111 .text.cli_Help 00000098  00003150  00003150  00013150  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
112 .text.cli_ArgsParse 000000f0  000031e8  000031e8  000131e8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
113 .text.cli_ArgsDispatch 000000a0  000032d8  000032d8  000132d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
114 .text.lcd_command 0000001a  00003378  00003378  00013378  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
115 .text.lcd_PutChar 0000001a  00003392  00003392  00013392  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
116 .text.lcd_Clear 00000018  000033ac  000033ac  000133ac  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
117 .text.lcd_SetCursor 0000002c  000033c4  000033c4  000133c4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
118 .text.lcd_Display 00000018  000033f0  000033f0  000133f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
119 .text.lcd_Init 000000b0  00003408  00003408  00013408  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
120 .text.lcd_CreateChar 0000003a  000034b8  000034b8  000134b8  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
121 .text.lcd_printfInit 00000020  000034f4  000034f4  000134f4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
122 .text.lcd_printf 0000005c  00003514  00003514  00013514  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
123 .text.lcd_config_ports 00000028  00003570  00003570  00013570  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
124 .text.lcd_read 00000090  00003598  00003598  00013598  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
125 .text.lcd_write 000000c8  00003628  00003628  00013628  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
126 .text.__get_current_locale 00000018  000036f0  000036f0  000136f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
127 .text.__locale_ctype_ptr 00000014  00003708  00003708  00013708  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
128 .text.__ascii_mbtowc 0000002c  0000371c  0000371c  0001371c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
129 .text.memset  0000009c  00003748  00003748  00013748  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
130 .text.strlen  0000005c  000037e4  000037e4  000137e4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
131 .text.__ascii_wctomb 0000001c  00003840  00003840  00013840  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
132 .rodata       0000088d  0000385c  0000385c  0001385c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
133 .data         000005d4  10000000  000040ec  00020000  2**3
                  CONTENTS, ALLOC, LOAD, DATA
134 .bss          00000025  100005d4  000046c0  000205d4  2**2
                  ALLOC
135 .bss.vicerr_Functions 00000004  100005fc  000046e8  000205d4  2**2
                  ALLOC
136 .bss.countTicksLed 00000004  10000600  000046ec  000205d4  2**2
                  ALLOC
137 .bss.countTicks_ms 00000004  10000604  000046f0  000205d4  2**2
                  ALLOC
138 .bss.callfuncTime 00000004  10000608  000046f4  000205d4  2**2
                  ALLOC
139 .bss.systime_IntFunctions 00000004  1000060c  000046f8  000205d4  2**2
                  ALLOC
140 .bss.u0_data_tx 00000096  10000610  000046fc  000205d4  2**0
                  ALLOC
141 .bss.u0_tx_running 00000001  100006a6  00004792  000205d4  2**0
                  ALLOC
142 .bss.u0_overflow_rx 00000002  100006a8  00004794  000205d4  2**1
                  ALLOC
143 .bss.u0_buf_rx 0000000c  100006ac  00004798  000205d4  2**2
                  ALLOC
144 .bss.u0_buf_tx 0000000c  100006b8  000047a4  000205d4  2**2
                  ALLOC
145 .bss.u0_data_rx 00000096  100006c4  000047b0  000205d4  2**0
                  ALLOC
146 .bss.x.4895   00000004  1000075c  00004848  000205d4  2**2
                  ALLOC
147 .bss.ticks_d.4856 00000004  10000760  0000484c  000205d4  2**2
                  ALLOC
148 .bss.bufKey.4850 0000000c  10000764  00004850  000205d4  2**2
                  ALLOC
149 .bss.timeReadKey.4849 00000004  10000770  0000485c  000205d4  2**2
                  ALLOC
150 .bss.idx.4851 00000004  10000774  00004860  000205d4  2**2
                  ALLOC
151 .bss.argc_prompt 00000004  10000778  00004864  000205d4  2**2
                  ALLOC
152 .bss.result_prompt 00000004  1000077c  00004868  000205d4  2**2
                  ALLOC
153 .bss.argv_prompt 00000028  10000780  0000486c  000205d4  2**2
                  ALLOC
154 .bss.buffer_prompt 00000028  100007a8  00004894  000205d4  2**0
                  ALLOC
155 .bss.dev1_putc 00000004  100007d0  000048bc  000205d4  2**2
                  ALLOC
156 .bss.dev2_putc 00000004  100007d4  000048c0  000205d4  2**2
                  ALLOC
157 .bss.stdio_putc 00000004  100007d8  000048c4  000205d4  2**2
                  ALLOC
158 .bss.dev4_putc 00000004  100007dc  000048c8  000205d4  2**2
                  ALLOC
159 .bss.dev3_putc 00000004  100007e0  000048cc  000205d4  2**2
                  ALLOC
160 .bss.putcharfunc.4764 00000004  100007e4  000048d0  000205d4  2**2
                  ALLOC
161 .bss.stdio_getc 00000004  100007e8  000048d4  000205d4  2**2
                  ALLOC
162 .bss.debug_putc 00000004  100007ec  000048d8  000205d4  2**2
                  ALLOC
163 .bss.err_putc 00000004  100007f0  000048dc  000205d4  2**2
                  ALLOC
164 .bss.nTimes.4279 00000004  100007f4  000048e0  000205d4  2**2
                  ALLOC
165 .bss.ff.4278  00000004  100007f8  000048e4  000205d4  2**2
                  ALLOC
166 .bss.count2.4277 00000004  100007fc  000048e8  000205d4  2**2
                  ALLOC
167 .bss.error    00000004  10000800  000048ec  000205d4  2**2
                  ALLOC
168 .bss.ledBlink 00000004  10000804  000048f0  000205d4  2**2
                  ALLOC
169 .bss.count1.4276 00000004  10000808  000048f4  000205d4  2**2
                  ALLOC
170 .bss.onKeyUp  00000004  1000080c  000048f8  000205d4  2**2
                  ALLOC
171 .bss.timeRepeat 00000004  10000810  000048fc  000205d4  2**2
                  ALLOC
172 .bss.estado.4276 00000001  10000814  00004900  000205d4  2**0
                  ALLOC
173 .bss.onKeyDown 00000004  10000818  00004904  000205d4  2**2
                  ALLOC
174 .bss.keynow.4275 00000001  1000081c  00004908  000205d4  2**0
                  ALLOC
175 .bss.repeat.4277 00000004  10000820  0000490c  000205d4  2**2
                  ALLOC
176 .bss.onKeyPress 00000004  10000824  00004910  000205d4  2**2
                  ALLOC
177 .bss.beep     00000030  10000828  00004914  000205d4  2**2
                  ALLOC
178 .bss.cmd_list_active 00000004  10000858  00004944  000205d4  2**2
                  ALLOC
179 .bss.p        00000004  1000085c  00004948  000205d4  2**2
                  ALLOC
180 .bss.c        00000001  10000860  0000494c  000205d4  2**0
                  ALLOC
181 .bss.devicePrintf 00000004  10000864  00004950  000205d4  2**2
                  ALLOC
182 .comment      0000006e  00000000  00000000  000205d4  2**0
                  CONTENTS, READONLY
183 .ARM.attributes 00000031  00000000  00000000  00020642  2**0
                  CONTENTS, READONLY
184 .debug_aranges 00000738  00000000  00000000  00020673  2**0
                  CONTENTS, READONLY, DEBUGGING
185 .debug_info   00005e51  00000000  00000000  00020dab  2**0
                  CONTENTS, READONLY, DEBUGGING
186 .debug_abbrev 00001d5a  00000000  00000000  00026bfc  2**0
                  CONTENTS, READONLY, DEBUGGING
187 .debug_line   0000221f  00000000  00000000  00028956  2**0
                  CONTENTS, READONLY, DEBUGGING
188 .debug_frame  0000156c  00000000  00000000  0002ab78  2**2
                  CONTENTS, READONLY, DEBUGGING
189 .debug_str    0000132f  00000000  00000000  0002c0e4  2**0
                  CONTENTS, READONLY, DEBUGGING
190 .debug_loc    000037a0  00000000  00000000  0002d413  2**0
                  CONTENTS, READONLY, DEBUGGING
191 .debug_ranges 00000758  00000000  00000000  00030bb3  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <gVectors>:
       0:	00 40 00 10 a1 13 00 00 e9 13 00 00 09 14 00 00     .@..............
      10:	59 14 00 00 79 14 00 00 99 14 00 00 00 00 00 00     Y...y...........
	...
      2c:	b9 14 00 00 d9 14 00 00 00 00 00 00 f9 14 00 00     ................
      3c:	11 1b 00 00 19 15 00 00 39 15 00 00 59 15 00 00     ........9...Y...
      4c:	79 15 00 00 99 15 00 00 e5 1d 00 00 b9 15 00 00     y...............
      5c:	d9 15 00 00 f9 15 00 00 19 16 00 00 39 16 00 00     ............9...
      6c:	59 16 00 00 79 16 00 00 99 16 00 00 b9 16 00 00     Y...y...........
      7c:	d9 16 00 00 f9 16 00 00 19 17 00 00 39 17 00 00     ............9...
      8c:	59 17 00 00 79 17 00 00 99 17 00 00 b9 17 00 00     Y...y...........
      9c:	d9 17 00 00 f9 17 00 00 19 18 00 00 39 18 00 00     ............9...
      ac:	59 18 00 00 79 18 00 00 99 18 00 00 b9 18 00 00     Y...y...........
      bc:	d9 18 00 00 f9 18 00 00 19 19 00 00 39 19 00 00     ............9...
      cc:	59 19 00 00 79 19 00 00 99 19 00 00 b9 19 00 00     Y...y...........
      dc:	d9 19 00 00 f9 19 00 00 00 00 00 00 00 00 00 00     ................
	...

000002fc <__aeabi_drsub>:
     2fc:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000
     300:	e002      	b.n	308 <__adddf3>
     302:	bf00      	nop

00000304 <__aeabi_dsub>:
     304:	f083 4300 	eor.w	r3, r3, #2147483648	; 0x80000000

00000308 <__adddf3>:
     308:	b530      	push	{r4, r5, lr}
     30a:	ea4f 0441 	mov.w	r4, r1, lsl #1
     30e:	ea4f 0543 	mov.w	r5, r3, lsl #1
     312:	ea94 0f05 	teq	r4, r5
     316:	bf08      	it	eq
     318:	ea90 0f02 	teqeq	r0, r2
     31c:	bf1f      	itttt	ne
     31e:	ea54 0c00 	orrsne.w	ip, r4, r0
     322:	ea55 0c02 	orrsne.w	ip, r5, r2
     326:	ea7f 5c64 	mvnsne.w	ip, r4, asr #21
     32a:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     32e:	f000 80e2 	beq.w	4f6 <__adddf3+0x1ee>
     332:	ea4f 5454 	mov.w	r4, r4, lsr #21
     336:	ebd4 5555 	rsbs	r5, r4, r5, lsr #21
     33a:	bfb8      	it	lt
     33c:	426d      	neglt	r5, r5
     33e:	dd0c      	ble.n	35a <__adddf3+0x52>
     340:	442c      	add	r4, r5
     342:	ea80 0202 	eor.w	r2, r0, r2
     346:	ea81 0303 	eor.w	r3, r1, r3
     34a:	ea82 0000 	eor.w	r0, r2, r0
     34e:	ea83 0101 	eor.w	r1, r3, r1
     352:	ea80 0202 	eor.w	r2, r0, r2
     356:	ea81 0303 	eor.w	r3, r1, r3
     35a:	2d36      	cmp	r5, #54	; 0x36
     35c:	bf88      	it	hi
     35e:	bd30      	pophi	{r4, r5, pc}
     360:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     364:	ea4f 3101 	mov.w	r1, r1, lsl #12
     368:	f44f 1c80 	mov.w	ip, #1048576	; 0x100000
     36c:	ea4c 3111 	orr.w	r1, ip, r1, lsr #12
     370:	d002      	beq.n	378 <__adddf3+0x70>
     372:	4240      	negs	r0, r0
     374:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     378:	f013 4f00 	tst.w	r3, #2147483648	; 0x80000000
     37c:	ea4f 3303 	mov.w	r3, r3, lsl #12
     380:	ea4c 3313 	orr.w	r3, ip, r3, lsr #12
     384:	d002      	beq.n	38c <__adddf3+0x84>
     386:	4252      	negs	r2, r2
     388:	eb63 0343 	sbc.w	r3, r3, r3, lsl #1
     38c:	ea94 0f05 	teq	r4, r5
     390:	f000 80a7 	beq.w	4e2 <__adddf3+0x1da>
     394:	f1a4 0401 	sub.w	r4, r4, #1
     398:	f1d5 0e20 	rsbs	lr, r5, #32
     39c:	db0d      	blt.n	3ba <__adddf3+0xb2>
     39e:	fa02 fc0e 	lsl.w	ip, r2, lr
     3a2:	fa22 f205 	lsr.w	r2, r2, r5
     3a6:	1880      	adds	r0, r0, r2
     3a8:	f141 0100 	adc.w	r1, r1, #0
     3ac:	fa03 f20e 	lsl.w	r2, r3, lr
     3b0:	1880      	adds	r0, r0, r2
     3b2:	fa43 f305 	asr.w	r3, r3, r5
     3b6:	4159      	adcs	r1, r3
     3b8:	e00e      	b.n	3d8 <__adddf3+0xd0>
     3ba:	f1a5 0520 	sub.w	r5, r5, #32
     3be:	f10e 0e20 	add.w	lr, lr, #32
     3c2:	2a01      	cmp	r2, #1
     3c4:	fa03 fc0e 	lsl.w	ip, r3, lr
     3c8:	bf28      	it	cs
     3ca:	f04c 0c02 	orrcs.w	ip, ip, #2
     3ce:	fa43 f305 	asr.w	r3, r3, r5
     3d2:	18c0      	adds	r0, r0, r3
     3d4:	eb51 71e3 	adcs.w	r1, r1, r3, asr #31
     3d8:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     3dc:	d507      	bpl.n	3ee <__adddf3+0xe6>
     3de:	f04f 0e00 	mov.w	lr, #0
     3e2:	f1dc 0c00 	rsbs	ip, ip, #0
     3e6:	eb7e 0000 	sbcs.w	r0, lr, r0
     3ea:	eb6e 0101 	sbc.w	r1, lr, r1
     3ee:	f5b1 1f80 	cmp.w	r1, #1048576	; 0x100000
     3f2:	d31b      	bcc.n	42c <__adddf3+0x124>
     3f4:	f5b1 1f00 	cmp.w	r1, #2097152	; 0x200000
     3f8:	d30c      	bcc.n	414 <__adddf3+0x10c>
     3fa:	0849      	lsrs	r1, r1, #1
     3fc:	ea5f 0030 	movs.w	r0, r0, rrx
     400:	ea4f 0c3c 	mov.w	ip, ip, rrx
     404:	f104 0401 	add.w	r4, r4, #1
     408:	ea4f 5244 	mov.w	r2, r4, lsl #21
     40c:	f512 0f80 	cmn.w	r2, #4194304	; 0x400000
     410:	f080 809a 	bcs.w	548 <__adddf3+0x240>
     414:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     418:	bf08      	it	eq
     41a:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     41e:	f150 0000 	adcs.w	r0, r0, #0
     422:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     426:	ea41 0105 	orr.w	r1, r1, r5
     42a:	bd30      	pop	{r4, r5, pc}
     42c:	ea5f 0c4c 	movs.w	ip, ip, lsl #1
     430:	4140      	adcs	r0, r0
     432:	eb41 0101 	adc.w	r1, r1, r1
     436:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     43a:	f1a4 0401 	sub.w	r4, r4, #1
     43e:	d1e9      	bne.n	414 <__adddf3+0x10c>
     440:	f091 0f00 	teq	r1, #0
     444:	bf04      	itt	eq
     446:	4601      	moveq	r1, r0
     448:	2000      	moveq	r0, #0
     44a:	fab1 f381 	clz	r3, r1
     44e:	bf08      	it	eq
     450:	3320      	addeq	r3, #32
     452:	f1a3 030b 	sub.w	r3, r3, #11
     456:	f1b3 0220 	subs.w	r2, r3, #32
     45a:	da0c      	bge.n	476 <__adddf3+0x16e>
     45c:	320c      	adds	r2, #12
     45e:	dd08      	ble.n	472 <__adddf3+0x16a>
     460:	f102 0c14 	add.w	ip, r2, #20
     464:	f1c2 020c 	rsb	r2, r2, #12
     468:	fa01 f00c 	lsl.w	r0, r1, ip
     46c:	fa21 f102 	lsr.w	r1, r1, r2
     470:	e00c      	b.n	48c <__adddf3+0x184>
     472:	f102 0214 	add.w	r2, r2, #20
     476:	bfd8      	it	le
     478:	f1c2 0c20 	rsble	ip, r2, #32
     47c:	fa01 f102 	lsl.w	r1, r1, r2
     480:	fa20 fc0c 	lsr.w	ip, r0, ip
     484:	bfdc      	itt	le
     486:	ea41 010c 	orrle.w	r1, r1, ip
     48a:	4090      	lslle	r0, r2
     48c:	1ae4      	subs	r4, r4, r3
     48e:	bfa2      	ittt	ge
     490:	eb01 5104 	addge.w	r1, r1, r4, lsl #20
     494:	4329      	orrge	r1, r5
     496:	bd30      	popge	{r4, r5, pc}
     498:	ea6f 0404 	mvn.w	r4, r4
     49c:	3c1f      	subs	r4, #31
     49e:	da1c      	bge.n	4da <__adddf3+0x1d2>
     4a0:	340c      	adds	r4, #12
     4a2:	dc0e      	bgt.n	4c2 <__adddf3+0x1ba>
     4a4:	f104 0414 	add.w	r4, r4, #20
     4a8:	f1c4 0220 	rsb	r2, r4, #32
     4ac:	fa20 f004 	lsr.w	r0, r0, r4
     4b0:	fa01 f302 	lsl.w	r3, r1, r2
     4b4:	ea40 0003 	orr.w	r0, r0, r3
     4b8:	fa21 f304 	lsr.w	r3, r1, r4
     4bc:	ea45 0103 	orr.w	r1, r5, r3
     4c0:	bd30      	pop	{r4, r5, pc}
     4c2:	f1c4 040c 	rsb	r4, r4, #12
     4c6:	f1c4 0220 	rsb	r2, r4, #32
     4ca:	fa20 f002 	lsr.w	r0, r0, r2
     4ce:	fa01 f304 	lsl.w	r3, r1, r4
     4d2:	ea40 0003 	orr.w	r0, r0, r3
     4d6:	4629      	mov	r1, r5
     4d8:	bd30      	pop	{r4, r5, pc}
     4da:	fa21 f004 	lsr.w	r0, r1, r4
     4de:	4629      	mov	r1, r5
     4e0:	bd30      	pop	{r4, r5, pc}
     4e2:	f094 0f00 	teq	r4, #0
     4e6:	f483 1380 	eor.w	r3, r3, #1048576	; 0x100000
     4ea:	bf06      	itte	eq
     4ec:	f481 1180 	eoreq.w	r1, r1, #1048576	; 0x100000
     4f0:	3401      	addeq	r4, #1
     4f2:	3d01      	subne	r5, #1
     4f4:	e74e      	b.n	394 <__adddf3+0x8c>
     4f6:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     4fa:	bf18      	it	ne
     4fc:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     500:	d029      	beq.n	556 <__adddf3+0x24e>
     502:	ea94 0f05 	teq	r4, r5
     506:	bf08      	it	eq
     508:	ea90 0f02 	teqeq	r0, r2
     50c:	d005      	beq.n	51a <__adddf3+0x212>
     50e:	ea54 0c00 	orrs.w	ip, r4, r0
     512:	bf04      	itt	eq
     514:	4619      	moveq	r1, r3
     516:	4610      	moveq	r0, r2
     518:	bd30      	pop	{r4, r5, pc}
     51a:	ea91 0f03 	teq	r1, r3
     51e:	bf1e      	ittt	ne
     520:	2100      	movne	r1, #0
     522:	2000      	movne	r0, #0
     524:	bd30      	popne	{r4, r5, pc}
     526:	ea5f 5c54 	movs.w	ip, r4, lsr #21
     52a:	d105      	bne.n	538 <__adddf3+0x230>
     52c:	0040      	lsls	r0, r0, #1
     52e:	4149      	adcs	r1, r1
     530:	bf28      	it	cs
     532:	f041 4100 	orrcs.w	r1, r1, #2147483648	; 0x80000000
     536:	bd30      	pop	{r4, r5, pc}
     538:	f514 0480 	adds.w	r4, r4, #4194304	; 0x400000
     53c:	bf3c      	itt	cc
     53e:	f501 1180 	addcc.w	r1, r1, #1048576	; 0x100000
     542:	bd30      	popcc	{r4, r5, pc}
     544:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     548:	f045 41fe 	orr.w	r1, r5, #2130706432	; 0x7f000000
     54c:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     550:	f04f 0000 	mov.w	r0, #0
     554:	bd30      	pop	{r4, r5, pc}
     556:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     55a:	bf1a      	itte	ne
     55c:	4619      	movne	r1, r3
     55e:	4610      	movne	r0, r2
     560:	ea7f 5c65 	mvnseq.w	ip, r5, asr #21
     564:	bf1c      	itt	ne
     566:	460b      	movne	r3, r1
     568:	4602      	movne	r2, r0
     56a:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     56e:	bf06      	itte	eq
     570:	ea52 3503 	orrseq.w	r5, r2, r3, lsl #12
     574:	ea91 0f03 	teqeq	r1, r3
     578:	f441 2100 	orrne.w	r1, r1, #524288	; 0x80000
     57c:	bd30      	pop	{r4, r5, pc}
     57e:	bf00      	nop

00000580 <__aeabi_ui2d>:
     580:	f090 0f00 	teq	r0, #0
     584:	bf04      	itt	eq
     586:	2100      	moveq	r1, #0
     588:	4770      	bxeq	lr
     58a:	b530      	push	{r4, r5, lr}
     58c:	f44f 6480 	mov.w	r4, #1024	; 0x400
     590:	f104 0432 	add.w	r4, r4, #50	; 0x32
     594:	f04f 0500 	mov.w	r5, #0
     598:	f04f 0100 	mov.w	r1, #0
     59c:	e750      	b.n	440 <__adddf3+0x138>
     59e:	bf00      	nop

000005a0 <__aeabi_i2d>:
     5a0:	f090 0f00 	teq	r0, #0
     5a4:	bf04      	itt	eq
     5a6:	2100      	moveq	r1, #0
     5a8:	4770      	bxeq	lr
     5aa:	b530      	push	{r4, r5, lr}
     5ac:	f44f 6480 	mov.w	r4, #1024	; 0x400
     5b0:	f104 0432 	add.w	r4, r4, #50	; 0x32
     5b4:	f010 4500 	ands.w	r5, r0, #2147483648	; 0x80000000
     5b8:	bf48      	it	mi
     5ba:	4240      	negmi	r0, r0
     5bc:	f04f 0100 	mov.w	r1, #0
     5c0:	e73e      	b.n	440 <__adddf3+0x138>
     5c2:	bf00      	nop

000005c4 <__aeabi_f2d>:
     5c4:	0042      	lsls	r2, r0, #1
     5c6:	ea4f 01e2 	mov.w	r1, r2, asr #3
     5ca:	ea4f 0131 	mov.w	r1, r1, rrx
     5ce:	ea4f 7002 	mov.w	r0, r2, lsl #28
     5d2:	bf1f      	itttt	ne
     5d4:	f012 437f 	andsne.w	r3, r2, #4278190080	; 0xff000000
     5d8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5dc:	f081 5160 	eorne.w	r1, r1, #939524096	; 0x38000000
     5e0:	4770      	bxne	lr
     5e2:	f092 0f00 	teq	r2, #0
     5e6:	bf14      	ite	ne
     5e8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5ec:	4770      	bxeq	lr
     5ee:	b530      	push	{r4, r5, lr}
     5f0:	f44f 7460 	mov.w	r4, #896	; 0x380
     5f4:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     5f8:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     5fc:	e720      	b.n	440 <__adddf3+0x138>
     5fe:	bf00      	nop

00000600 <__aeabi_ul2d>:
     600:	ea50 0201 	orrs.w	r2, r0, r1
     604:	bf08      	it	eq
     606:	4770      	bxeq	lr
     608:	b530      	push	{r4, r5, lr}
     60a:	f04f 0500 	mov.w	r5, #0
     60e:	e00a      	b.n	626 <__aeabi_l2d+0x16>

00000610 <__aeabi_l2d>:
     610:	ea50 0201 	orrs.w	r2, r0, r1
     614:	bf08      	it	eq
     616:	4770      	bxeq	lr
     618:	b530      	push	{r4, r5, lr}
     61a:	f011 4500 	ands.w	r5, r1, #2147483648	; 0x80000000
     61e:	d502      	bpl.n	626 <__aeabi_l2d+0x16>
     620:	4240      	negs	r0, r0
     622:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     626:	f44f 6480 	mov.w	r4, #1024	; 0x400
     62a:	f104 0432 	add.w	r4, r4, #50	; 0x32
     62e:	ea5f 5c91 	movs.w	ip, r1, lsr #22
     632:	f43f aedc 	beq.w	3ee <__adddf3+0xe6>
     636:	f04f 0203 	mov.w	r2, #3
     63a:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     63e:	bf18      	it	ne
     640:	3203      	addne	r2, #3
     642:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     646:	bf18      	it	ne
     648:	3203      	addne	r2, #3
     64a:	eb02 02dc 	add.w	r2, r2, ip, lsr #3
     64e:	f1c2 0320 	rsb	r3, r2, #32
     652:	fa00 fc03 	lsl.w	ip, r0, r3
     656:	fa20 f002 	lsr.w	r0, r0, r2
     65a:	fa01 fe03 	lsl.w	lr, r1, r3
     65e:	ea40 000e 	orr.w	r0, r0, lr
     662:	fa21 f102 	lsr.w	r1, r1, r2
     666:	4414      	add	r4, r2
     668:	e6c1      	b.n	3ee <__adddf3+0xe6>
     66a:	bf00      	nop

0000066c <__aeabi_dmul>:
     66c:	b570      	push	{r4, r5, r6, lr}
     66e:	f04f 0cff 	mov.w	ip, #255	; 0xff
     672:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     676:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     67a:	bf1d      	ittte	ne
     67c:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     680:	ea94 0f0c 	teqne	r4, ip
     684:	ea95 0f0c 	teqne	r5, ip
     688:	f000 f8de 	bleq	848 <__aeabi_dmul+0x1dc>
     68c:	442c      	add	r4, r5
     68e:	ea81 0603 	eor.w	r6, r1, r3
     692:	ea21 514c 	bic.w	r1, r1, ip, lsl #21
     696:	ea23 534c 	bic.w	r3, r3, ip, lsl #21
     69a:	ea50 3501 	orrs.w	r5, r0, r1, lsl #12
     69e:	bf18      	it	ne
     6a0:	ea52 3503 	orrsne.w	r5, r2, r3, lsl #12
     6a4:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     6a8:	f443 1380 	orr.w	r3, r3, #1048576	; 0x100000
     6ac:	d038      	beq.n	720 <__aeabi_dmul+0xb4>
     6ae:	fba0 ce02 	umull	ip, lr, r0, r2
     6b2:	f04f 0500 	mov.w	r5, #0
     6b6:	fbe1 e502 	umlal	lr, r5, r1, r2
     6ba:	f006 4200 	and.w	r2, r6, #2147483648	; 0x80000000
     6be:	fbe0 e503 	umlal	lr, r5, r0, r3
     6c2:	f04f 0600 	mov.w	r6, #0
     6c6:	fbe1 5603 	umlal	r5, r6, r1, r3
     6ca:	f09c 0f00 	teq	ip, #0
     6ce:	bf18      	it	ne
     6d0:	f04e 0e01 	orrne.w	lr, lr, #1
     6d4:	f1a4 04ff 	sub.w	r4, r4, #255	; 0xff
     6d8:	f5b6 7f00 	cmp.w	r6, #512	; 0x200
     6dc:	f564 7440 	sbc.w	r4, r4, #768	; 0x300
     6e0:	d204      	bcs.n	6ec <__aeabi_dmul+0x80>
     6e2:	ea5f 0e4e 	movs.w	lr, lr, lsl #1
     6e6:	416d      	adcs	r5, r5
     6e8:	eb46 0606 	adc.w	r6, r6, r6
     6ec:	ea42 21c6 	orr.w	r1, r2, r6, lsl #11
     6f0:	ea41 5155 	orr.w	r1, r1, r5, lsr #21
     6f4:	ea4f 20c5 	mov.w	r0, r5, lsl #11
     6f8:	ea40 505e 	orr.w	r0, r0, lr, lsr #21
     6fc:	ea4f 2ece 	mov.w	lr, lr, lsl #11
     700:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     704:	bf88      	it	hi
     706:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     70a:	d81e      	bhi.n	74a <__aeabi_dmul+0xde>
     70c:	f1be 4f00 	cmp.w	lr, #2147483648	; 0x80000000
     710:	bf08      	it	eq
     712:	ea5f 0e50 	movseq.w	lr, r0, lsr #1
     716:	f150 0000 	adcs.w	r0, r0, #0
     71a:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     71e:	bd70      	pop	{r4, r5, r6, pc}
     720:	f006 4600 	and.w	r6, r6, #2147483648	; 0x80000000
     724:	ea46 0101 	orr.w	r1, r6, r1
     728:	ea40 0002 	orr.w	r0, r0, r2
     72c:	ea81 0103 	eor.w	r1, r1, r3
     730:	ebb4 045c 	subs.w	r4, r4, ip, lsr #1
     734:	bfc2      	ittt	gt
     736:	ebd4 050c 	rsbsgt	r5, r4, ip
     73a:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     73e:	bd70      	popgt	{r4, r5, r6, pc}
     740:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     744:	f04f 0e00 	mov.w	lr, #0
     748:	3c01      	subs	r4, #1
     74a:	f300 80ab 	bgt.w	8a4 <__aeabi_dmul+0x238>
     74e:	f114 0f36 	cmn.w	r4, #54	; 0x36
     752:	bfde      	ittt	le
     754:	2000      	movle	r0, #0
     756:	f001 4100 	andle.w	r1, r1, #2147483648	; 0x80000000
     75a:	bd70      	pople	{r4, r5, r6, pc}
     75c:	f1c4 0400 	rsb	r4, r4, #0
     760:	3c20      	subs	r4, #32
     762:	da35      	bge.n	7d0 <__aeabi_dmul+0x164>
     764:	340c      	adds	r4, #12
     766:	dc1b      	bgt.n	7a0 <__aeabi_dmul+0x134>
     768:	f104 0414 	add.w	r4, r4, #20
     76c:	f1c4 0520 	rsb	r5, r4, #32
     770:	fa00 f305 	lsl.w	r3, r0, r5
     774:	fa20 f004 	lsr.w	r0, r0, r4
     778:	fa01 f205 	lsl.w	r2, r1, r5
     77c:	ea40 0002 	orr.w	r0, r0, r2
     780:	f001 4200 	and.w	r2, r1, #2147483648	; 0x80000000
     784:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     788:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     78c:	fa21 f604 	lsr.w	r6, r1, r4
     790:	eb42 0106 	adc.w	r1, r2, r6
     794:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     798:	bf08      	it	eq
     79a:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     79e:	bd70      	pop	{r4, r5, r6, pc}
     7a0:	f1c4 040c 	rsb	r4, r4, #12
     7a4:	f1c4 0520 	rsb	r5, r4, #32
     7a8:	fa00 f304 	lsl.w	r3, r0, r4
     7ac:	fa20 f005 	lsr.w	r0, r0, r5
     7b0:	fa01 f204 	lsl.w	r2, r1, r4
     7b4:	ea40 0002 	orr.w	r0, r0, r2
     7b8:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7bc:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     7c0:	f141 0100 	adc.w	r1, r1, #0
     7c4:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     7c8:	bf08      	it	eq
     7ca:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     7ce:	bd70      	pop	{r4, r5, r6, pc}
     7d0:	f1c4 0520 	rsb	r5, r4, #32
     7d4:	fa00 f205 	lsl.w	r2, r0, r5
     7d8:	ea4e 0e02 	orr.w	lr, lr, r2
     7dc:	fa20 f304 	lsr.w	r3, r0, r4
     7e0:	fa01 f205 	lsl.w	r2, r1, r5
     7e4:	ea43 0302 	orr.w	r3, r3, r2
     7e8:	fa21 f004 	lsr.w	r0, r1, r4
     7ec:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7f0:	fa21 f204 	lsr.w	r2, r1, r4
     7f4:	ea20 0002 	bic.w	r0, r0, r2
     7f8:	eb00 70d3 	add.w	r0, r0, r3, lsr #31
     7fc:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     800:	bf08      	it	eq
     802:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     806:	bd70      	pop	{r4, r5, r6, pc}
     808:	f094 0f00 	teq	r4, #0
     80c:	d10f      	bne.n	82e <__aeabi_dmul+0x1c2>
     80e:	f001 4600 	and.w	r6, r1, #2147483648	; 0x80000000
     812:	0040      	lsls	r0, r0, #1
     814:	eb41 0101 	adc.w	r1, r1, r1
     818:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     81c:	bf08      	it	eq
     81e:	3c01      	subeq	r4, #1
     820:	d0f7      	beq.n	812 <__aeabi_dmul+0x1a6>
     822:	ea41 0106 	orr.w	r1, r1, r6
     826:	f095 0f00 	teq	r5, #0
     82a:	bf18      	it	ne
     82c:	4770      	bxne	lr
     82e:	f003 4600 	and.w	r6, r3, #2147483648	; 0x80000000
     832:	0052      	lsls	r2, r2, #1
     834:	eb43 0303 	adc.w	r3, r3, r3
     838:	f413 1f80 	tst.w	r3, #1048576	; 0x100000
     83c:	bf08      	it	eq
     83e:	3d01      	subeq	r5, #1
     840:	d0f7      	beq.n	832 <__aeabi_dmul+0x1c6>
     842:	ea43 0306 	orr.w	r3, r3, r6
     846:	4770      	bx	lr
     848:	ea94 0f0c 	teq	r4, ip
     84c:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     850:	bf18      	it	ne
     852:	ea95 0f0c 	teqne	r5, ip
     856:	d00c      	beq.n	872 <__aeabi_dmul+0x206>
     858:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     85c:	bf18      	it	ne
     85e:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     862:	d1d1      	bne.n	808 <__aeabi_dmul+0x19c>
     864:	ea81 0103 	eor.w	r1, r1, r3
     868:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     86c:	f04f 0000 	mov.w	r0, #0
     870:	bd70      	pop	{r4, r5, r6, pc}
     872:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     876:	bf06      	itte	eq
     878:	4610      	moveq	r0, r2
     87a:	4619      	moveq	r1, r3
     87c:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     880:	d019      	beq.n	8b6 <__aeabi_dmul+0x24a>
     882:	ea94 0f0c 	teq	r4, ip
     886:	d102      	bne.n	88e <__aeabi_dmul+0x222>
     888:	ea50 3601 	orrs.w	r6, r0, r1, lsl #12
     88c:	d113      	bne.n	8b6 <__aeabi_dmul+0x24a>
     88e:	ea95 0f0c 	teq	r5, ip
     892:	d105      	bne.n	8a0 <__aeabi_dmul+0x234>
     894:	ea52 3603 	orrs.w	r6, r2, r3, lsl #12
     898:	bf1c      	itt	ne
     89a:	4610      	movne	r0, r2
     89c:	4619      	movne	r1, r3
     89e:	d10a      	bne.n	8b6 <__aeabi_dmul+0x24a>
     8a0:	ea81 0103 	eor.w	r1, r1, r3
     8a4:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     8a8:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ac:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     8b0:	f04f 0000 	mov.w	r0, #0
     8b4:	bd70      	pop	{r4, r5, r6, pc}
     8b6:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ba:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
     8be:	bd70      	pop	{r4, r5, r6, pc}

000008c0 <__aeabi_ddiv>:
     8c0:	b570      	push	{r4, r5, r6, lr}
     8c2:	f04f 0cff 	mov.w	ip, #255	; 0xff
     8c6:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     8ca:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     8ce:	bf1d      	ittte	ne
     8d0:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     8d4:	ea94 0f0c 	teqne	r4, ip
     8d8:	ea95 0f0c 	teqne	r5, ip
     8dc:	f000 f8a7 	bleq	a2e <__aeabi_ddiv+0x16e>
     8e0:	eba4 0405 	sub.w	r4, r4, r5
     8e4:	ea81 0e03 	eor.w	lr, r1, r3
     8e8:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     8ec:	ea4f 3101 	mov.w	r1, r1, lsl #12
     8f0:	f000 8088 	beq.w	a04 <__aeabi_ddiv+0x144>
     8f4:	ea4f 3303 	mov.w	r3, r3, lsl #12
     8f8:	f04f 5580 	mov.w	r5, #268435456	; 0x10000000
     8fc:	ea45 1313 	orr.w	r3, r5, r3, lsr #4
     900:	ea43 6312 	orr.w	r3, r3, r2, lsr #24
     904:	ea4f 2202 	mov.w	r2, r2, lsl #8
     908:	ea45 1511 	orr.w	r5, r5, r1, lsr #4
     90c:	ea45 6510 	orr.w	r5, r5, r0, lsr #24
     910:	ea4f 2600 	mov.w	r6, r0, lsl #8
     914:	f00e 4100 	and.w	r1, lr, #2147483648	; 0x80000000
     918:	429d      	cmp	r5, r3
     91a:	bf08      	it	eq
     91c:	4296      	cmpeq	r6, r2
     91e:	f144 04fd 	adc.w	r4, r4, #253	; 0xfd
     922:	f504 7440 	add.w	r4, r4, #768	; 0x300
     926:	d202      	bcs.n	92e <__aeabi_ddiv+0x6e>
     928:	085b      	lsrs	r3, r3, #1
     92a:	ea4f 0232 	mov.w	r2, r2, rrx
     92e:	1ab6      	subs	r6, r6, r2
     930:	eb65 0503 	sbc.w	r5, r5, r3
     934:	085b      	lsrs	r3, r3, #1
     936:	ea4f 0232 	mov.w	r2, r2, rrx
     93a:	f44f 1080 	mov.w	r0, #1048576	; 0x100000
     93e:	f44f 2c00 	mov.w	ip, #524288	; 0x80000
     942:	ebb6 0e02 	subs.w	lr, r6, r2
     946:	eb75 0e03 	sbcs.w	lr, r5, r3
     94a:	bf22      	ittt	cs
     94c:	1ab6      	subcs	r6, r6, r2
     94e:	4675      	movcs	r5, lr
     950:	ea40 000c 	orrcs.w	r0, r0, ip
     954:	085b      	lsrs	r3, r3, #1
     956:	ea4f 0232 	mov.w	r2, r2, rrx
     95a:	ebb6 0e02 	subs.w	lr, r6, r2
     95e:	eb75 0e03 	sbcs.w	lr, r5, r3
     962:	bf22      	ittt	cs
     964:	1ab6      	subcs	r6, r6, r2
     966:	4675      	movcs	r5, lr
     968:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     96c:	085b      	lsrs	r3, r3, #1
     96e:	ea4f 0232 	mov.w	r2, r2, rrx
     972:	ebb6 0e02 	subs.w	lr, r6, r2
     976:	eb75 0e03 	sbcs.w	lr, r5, r3
     97a:	bf22      	ittt	cs
     97c:	1ab6      	subcs	r6, r6, r2
     97e:	4675      	movcs	r5, lr
     980:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     984:	085b      	lsrs	r3, r3, #1
     986:	ea4f 0232 	mov.w	r2, r2, rrx
     98a:	ebb6 0e02 	subs.w	lr, r6, r2
     98e:	eb75 0e03 	sbcs.w	lr, r5, r3
     992:	bf22      	ittt	cs
     994:	1ab6      	subcs	r6, r6, r2
     996:	4675      	movcs	r5, lr
     998:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     99c:	ea55 0e06 	orrs.w	lr, r5, r6
     9a0:	d018      	beq.n	9d4 <__aeabi_ddiv+0x114>
     9a2:	ea4f 1505 	mov.w	r5, r5, lsl #4
     9a6:	ea45 7516 	orr.w	r5, r5, r6, lsr #28
     9aa:	ea4f 1606 	mov.w	r6, r6, lsl #4
     9ae:	ea4f 03c3 	mov.w	r3, r3, lsl #3
     9b2:	ea43 7352 	orr.w	r3, r3, r2, lsr #29
     9b6:	ea4f 02c2 	mov.w	r2, r2, lsl #3
     9ba:	ea5f 1c1c 	movs.w	ip, ip, lsr #4
     9be:	d1c0      	bne.n	942 <__aeabi_ddiv+0x82>
     9c0:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9c4:	d10b      	bne.n	9de <__aeabi_ddiv+0x11e>
     9c6:	ea41 0100 	orr.w	r1, r1, r0
     9ca:	f04f 0000 	mov.w	r0, #0
     9ce:	f04f 4c00 	mov.w	ip, #2147483648	; 0x80000000
     9d2:	e7b6      	b.n	942 <__aeabi_ddiv+0x82>
     9d4:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9d8:	bf04      	itt	eq
     9da:	4301      	orreq	r1, r0
     9dc:	2000      	moveq	r0, #0
     9de:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     9e2:	bf88      	it	hi
     9e4:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     9e8:	f63f aeaf 	bhi.w	74a <__aeabi_dmul+0xde>
     9ec:	ebb5 0c03 	subs.w	ip, r5, r3
     9f0:	bf04      	itt	eq
     9f2:	ebb6 0c02 	subseq.w	ip, r6, r2
     9f6:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     9fa:	f150 0000 	adcs.w	r0, r0, #0
     9fe:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     a02:	bd70      	pop	{r4, r5, r6, pc}
     a04:	f00e 4e00 	and.w	lr, lr, #2147483648	; 0x80000000
     a08:	ea4e 3111 	orr.w	r1, lr, r1, lsr #12
     a0c:	eb14 045c 	adds.w	r4, r4, ip, lsr #1
     a10:	bfc2      	ittt	gt
     a12:	ebd4 050c 	rsbsgt	r5, r4, ip
     a16:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     a1a:	bd70      	popgt	{r4, r5, r6, pc}
     a1c:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     a20:	f04f 0e00 	mov.w	lr, #0
     a24:	3c01      	subs	r4, #1
     a26:	e690      	b.n	74a <__aeabi_dmul+0xde>
     a28:	ea45 0e06 	orr.w	lr, r5, r6
     a2c:	e68d      	b.n	74a <__aeabi_dmul+0xde>
     a2e:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     a32:	ea94 0f0c 	teq	r4, ip
     a36:	bf08      	it	eq
     a38:	ea95 0f0c 	teqeq	r5, ip
     a3c:	f43f af3b 	beq.w	8b6 <__aeabi_dmul+0x24a>
     a40:	ea94 0f0c 	teq	r4, ip
     a44:	d10a      	bne.n	a5c <__aeabi_ddiv+0x19c>
     a46:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     a4a:	f47f af34 	bne.w	8b6 <__aeabi_dmul+0x24a>
     a4e:	ea95 0f0c 	teq	r5, ip
     a52:	f47f af25 	bne.w	8a0 <__aeabi_dmul+0x234>
     a56:	4610      	mov	r0, r2
     a58:	4619      	mov	r1, r3
     a5a:	e72c      	b.n	8b6 <__aeabi_dmul+0x24a>
     a5c:	ea95 0f0c 	teq	r5, ip
     a60:	d106      	bne.n	a70 <__aeabi_ddiv+0x1b0>
     a62:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     a66:	f43f aefd 	beq.w	864 <__aeabi_dmul+0x1f8>
     a6a:	4610      	mov	r0, r2
     a6c:	4619      	mov	r1, r3
     a6e:	e722      	b.n	8b6 <__aeabi_dmul+0x24a>
     a70:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     a74:	bf18      	it	ne
     a76:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     a7a:	f47f aec5 	bne.w	808 <__aeabi_dmul+0x19c>
     a7e:	ea50 0441 	orrs.w	r4, r0, r1, lsl #1
     a82:	f47f af0d 	bne.w	8a0 <__aeabi_dmul+0x234>
     a86:	ea52 0543 	orrs.w	r5, r2, r3, lsl #1
     a8a:	f47f aeeb 	bne.w	864 <__aeabi_dmul+0x1f8>
     a8e:	e712      	b.n	8b6 <__aeabi_dmul+0x24a>

00000a90 <__gedf2>:
     a90:	f04f 3cff 	mov.w	ip, #4294967295
     a94:	e006      	b.n	aa4 <__cmpdf2+0x4>
     a96:	bf00      	nop

00000a98 <__ledf2>:
     a98:	f04f 0c01 	mov.w	ip, #1
     a9c:	e002      	b.n	aa4 <__cmpdf2+0x4>
     a9e:	bf00      	nop

00000aa0 <__cmpdf2>:
     aa0:	f04f 0c01 	mov.w	ip, #1
     aa4:	f84d cd04 	str.w	ip, [sp, #-4]!
     aa8:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     aac:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     ab0:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     ab4:	bf18      	it	ne
     ab6:	ea7f 5c6c 	mvnsne.w	ip, ip, asr #21
     aba:	d01b      	beq.n	af4 <__cmpdf2+0x54>
     abc:	b001      	add	sp, #4
     abe:	ea50 0c41 	orrs.w	ip, r0, r1, lsl #1
     ac2:	bf0c      	ite	eq
     ac4:	ea52 0c43 	orrseq.w	ip, r2, r3, lsl #1
     ac8:	ea91 0f03 	teqne	r1, r3
     acc:	bf02      	ittt	eq
     ace:	ea90 0f02 	teqeq	r0, r2
     ad2:	2000      	moveq	r0, #0
     ad4:	4770      	bxeq	lr
     ad6:	f110 0f00 	cmn.w	r0, #0
     ada:	ea91 0f03 	teq	r1, r3
     ade:	bf58      	it	pl
     ae0:	4299      	cmppl	r1, r3
     ae2:	bf08      	it	eq
     ae4:	4290      	cmpeq	r0, r2
     ae6:	bf2c      	ite	cs
     ae8:	17d8      	asrcs	r0, r3, #31
     aea:	ea6f 70e3 	mvncc.w	r0, r3, asr #31
     aee:	f040 0001 	orr.w	r0, r0, #1
     af2:	4770      	bx	lr
     af4:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     af8:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     afc:	d102      	bne.n	b04 <__cmpdf2+0x64>
     afe:	ea50 3c01 	orrs.w	ip, r0, r1, lsl #12
     b02:	d107      	bne.n	b14 <__cmpdf2+0x74>
     b04:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     b08:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     b0c:	d1d6      	bne.n	abc <__cmpdf2+0x1c>
     b0e:	ea52 3c03 	orrs.w	ip, r2, r3, lsl #12
     b12:	d0d3      	beq.n	abc <__cmpdf2+0x1c>
     b14:	f85d 0b04 	ldr.w	r0, [sp], #4
     b18:	4770      	bx	lr
     b1a:	bf00      	nop

00000b1c <__aeabi_cdrcmple>:
     b1c:	4684      	mov	ip, r0
     b1e:	4610      	mov	r0, r2
     b20:	4662      	mov	r2, ip
     b22:	468c      	mov	ip, r1
     b24:	4619      	mov	r1, r3
     b26:	4663      	mov	r3, ip
     b28:	e000      	b.n	b2c <__aeabi_cdcmpeq>
     b2a:	bf00      	nop

00000b2c <__aeabi_cdcmpeq>:
     b2c:	b501      	push	{r0, lr}
     b2e:	f7ff ffb7 	bl	aa0 <__cmpdf2>
     b32:	2800      	cmp	r0, #0
     b34:	bf48      	it	mi
     b36:	f110 0f00 	cmnmi.w	r0, #0
     b3a:	bd01      	pop	{r0, pc}

00000b3c <__aeabi_dcmpeq>:
     b3c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b40:	f7ff fff4 	bl	b2c <__aeabi_cdcmpeq>
     b44:	bf0c      	ite	eq
     b46:	2001      	moveq	r0, #1
     b48:	2000      	movne	r0, #0
     b4a:	f85d fb08 	ldr.w	pc, [sp], #8
     b4e:	bf00      	nop

00000b50 <__aeabi_dcmplt>:
     b50:	f84d ed08 	str.w	lr, [sp, #-8]!
     b54:	f7ff ffea 	bl	b2c <__aeabi_cdcmpeq>
     b58:	bf34      	ite	cc
     b5a:	2001      	movcc	r0, #1
     b5c:	2000      	movcs	r0, #0
     b5e:	f85d fb08 	ldr.w	pc, [sp], #8
     b62:	bf00      	nop

00000b64 <__aeabi_dcmple>:
     b64:	f84d ed08 	str.w	lr, [sp, #-8]!
     b68:	f7ff ffe0 	bl	b2c <__aeabi_cdcmpeq>
     b6c:	bf94      	ite	ls
     b6e:	2001      	movls	r0, #1
     b70:	2000      	movhi	r0, #0
     b72:	f85d fb08 	ldr.w	pc, [sp], #8
     b76:	bf00      	nop

00000b78 <__aeabi_dcmpge>:
     b78:	f84d ed08 	str.w	lr, [sp, #-8]!
     b7c:	f7ff ffce 	bl	b1c <__aeabi_cdrcmple>
     b80:	bf94      	ite	ls
     b82:	2001      	movls	r0, #1
     b84:	2000      	movhi	r0, #0
     b86:	f85d fb08 	ldr.w	pc, [sp], #8
     b8a:	bf00      	nop

00000b8c <__aeabi_dcmpgt>:
     b8c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b90:	f7ff ffc4 	bl	b1c <__aeabi_cdrcmple>
     b94:	bf34      	ite	cc
     b96:	2001      	movcc	r0, #1
     b98:	2000      	movcs	r0, #0
     b9a:	f85d fb08 	ldr.w	pc, [sp], #8
     b9e:	bf00      	nop

00000ba0 <__aeabi_d2iz>:
     ba0:	ea4f 0241 	mov.w	r2, r1, lsl #1
     ba4:	f512 1200 	adds.w	r2, r2, #2097152	; 0x200000
     ba8:	d215      	bcs.n	bd6 <__aeabi_d2iz+0x36>
     baa:	d511      	bpl.n	bd0 <__aeabi_d2iz+0x30>
     bac:	f46f 7378 	mvn.w	r3, #992	; 0x3e0
     bb0:	ebb3 5262 	subs.w	r2, r3, r2, asr #21
     bb4:	d912      	bls.n	bdc <__aeabi_d2iz+0x3c>
     bb6:	ea4f 23c1 	mov.w	r3, r1, lsl #11
     bba:	f043 4300 	orr.w	r3, r3, #2147483648	; 0x80000000
     bbe:	ea43 5350 	orr.w	r3, r3, r0, lsr #21
     bc2:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     bc6:	fa23 f002 	lsr.w	r0, r3, r2
     bca:	bf18      	it	ne
     bcc:	4240      	negne	r0, r0
     bce:	4770      	bx	lr
     bd0:	f04f 0000 	mov.w	r0, #0
     bd4:	4770      	bx	lr
     bd6:	ea50 3001 	orrs.w	r0, r0, r1, lsl #12
     bda:	d105      	bne.n	be8 <__aeabi_d2iz+0x48>
     bdc:	f011 4000 	ands.w	r0, r1, #2147483648	; 0x80000000
     be0:	bf08      	it	eq
     be2:	f06f 4000 	mvneq.w	r0, #2147483648	; 0x80000000
     be6:	4770      	bx	lr
     be8:	f04f 0000 	mov.w	r0, #0
     bec:	4770      	bx	lr
     bee:	bf00      	nop

00000bf0 <__aeabi_frsub>:
     bf0:	f080 4000 	eor.w	r0, r0, #2147483648	; 0x80000000
     bf4:	e002      	b.n	bfc <__addsf3>
     bf6:	bf00      	nop

00000bf8 <__aeabi_fsub>:
     bf8:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000

00000bfc <__addsf3>:
     bfc:	0042      	lsls	r2, r0, #1
     bfe:	bf1f      	itttt	ne
     c00:	ea5f 0341 	movsne.w	r3, r1, lsl #1
     c04:	ea92 0f03 	teqne	r2, r3
     c08:	ea7f 6c22 	mvnsne.w	ip, r2, asr #24
     c0c:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     c10:	d06a      	beq.n	ce8 <__addsf3+0xec>
     c12:	ea4f 6212 	mov.w	r2, r2, lsr #24
     c16:	ebd2 6313 	rsbs	r3, r2, r3, lsr #24
     c1a:	bfc1      	itttt	gt
     c1c:	18d2      	addgt	r2, r2, r3
     c1e:	4041      	eorgt	r1, r0
     c20:	4048      	eorgt	r0, r1
     c22:	4041      	eorgt	r1, r0
     c24:	bfb8      	it	lt
     c26:	425b      	neglt	r3, r3
     c28:	2b19      	cmp	r3, #25
     c2a:	bf88      	it	hi
     c2c:	4770      	bxhi	lr
     c2e:	f010 4f00 	tst.w	r0, #2147483648	; 0x80000000
     c32:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     c36:	f020 407f 	bic.w	r0, r0, #4278190080	; 0xff000000
     c3a:	bf18      	it	ne
     c3c:	4240      	negne	r0, r0
     c3e:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     c42:	f441 0100 	orr.w	r1, r1, #8388608	; 0x800000
     c46:	f021 417f 	bic.w	r1, r1, #4278190080	; 0xff000000
     c4a:	bf18      	it	ne
     c4c:	4249      	negne	r1, r1
     c4e:	ea92 0f03 	teq	r2, r3
     c52:	d03f      	beq.n	cd4 <__addsf3+0xd8>
     c54:	f1a2 0201 	sub.w	r2, r2, #1
     c58:	fa41 fc03 	asr.w	ip, r1, r3
     c5c:	eb10 000c 	adds.w	r0, r0, ip
     c60:	f1c3 0320 	rsb	r3, r3, #32
     c64:	fa01 f103 	lsl.w	r1, r1, r3
     c68:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     c6c:	d502      	bpl.n	c74 <__addsf3+0x78>
     c6e:	4249      	negs	r1, r1
     c70:	eb60 0040 	sbc.w	r0, r0, r0, lsl #1
     c74:	f5b0 0f00 	cmp.w	r0, #8388608	; 0x800000
     c78:	d313      	bcc.n	ca2 <__addsf3+0xa6>
     c7a:	f1b0 7f80 	cmp.w	r0, #16777216	; 0x1000000
     c7e:	d306      	bcc.n	c8e <__addsf3+0x92>
     c80:	0840      	lsrs	r0, r0, #1
     c82:	ea4f 0131 	mov.w	r1, r1, rrx
     c86:	f102 0201 	add.w	r2, r2, #1
     c8a:	2afe      	cmp	r2, #254	; 0xfe
     c8c:	d251      	bcs.n	d32 <__addsf3+0x136>
     c8e:	f1b1 4f00 	cmp.w	r1, #2147483648	; 0x80000000
     c92:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     c96:	bf08      	it	eq
     c98:	f020 0001 	biceq.w	r0, r0, #1
     c9c:	ea40 0003 	orr.w	r0, r0, r3
     ca0:	4770      	bx	lr
     ca2:	0049      	lsls	r1, r1, #1
     ca4:	eb40 0000 	adc.w	r0, r0, r0
     ca8:	f410 0f00 	tst.w	r0, #8388608	; 0x800000
     cac:	f1a2 0201 	sub.w	r2, r2, #1
     cb0:	d1ed      	bne.n	c8e <__addsf3+0x92>
     cb2:	fab0 fc80 	clz	ip, r0
     cb6:	f1ac 0c08 	sub.w	ip, ip, #8
     cba:	ebb2 020c 	subs.w	r2, r2, ip
     cbe:	fa00 f00c 	lsl.w	r0, r0, ip
     cc2:	bfaa      	itet	ge
     cc4:	eb00 50c2 	addge.w	r0, r0, r2, lsl #23
     cc8:	4252      	neglt	r2, r2
     cca:	4318      	orrge	r0, r3
     ccc:	bfbc      	itt	lt
     cce:	40d0      	lsrlt	r0, r2
     cd0:	4318      	orrlt	r0, r3
     cd2:	4770      	bx	lr
     cd4:	f092 0f00 	teq	r2, #0
     cd8:	f481 0100 	eor.w	r1, r1, #8388608	; 0x800000
     cdc:	bf06      	itte	eq
     cde:	f480 0000 	eoreq.w	r0, r0, #8388608	; 0x800000
     ce2:	3201      	addeq	r2, #1
     ce4:	3b01      	subne	r3, #1
     ce6:	e7b5      	b.n	c54 <__addsf3+0x58>
     ce8:	ea4f 0341 	mov.w	r3, r1, lsl #1
     cec:	ea7f 6c22 	mvns.w	ip, r2, asr #24
     cf0:	bf18      	it	ne
     cf2:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     cf6:	d021      	beq.n	d3c <__addsf3+0x140>
     cf8:	ea92 0f03 	teq	r2, r3
     cfc:	d004      	beq.n	d08 <__addsf3+0x10c>
     cfe:	f092 0f00 	teq	r2, #0
     d02:	bf08      	it	eq
     d04:	4608      	moveq	r0, r1
     d06:	4770      	bx	lr
     d08:	ea90 0f01 	teq	r0, r1
     d0c:	bf1c      	itt	ne
     d0e:	2000      	movne	r0, #0
     d10:	4770      	bxne	lr
     d12:	f012 4f7f 	tst.w	r2, #4278190080	; 0xff000000
     d16:	d104      	bne.n	d22 <__addsf3+0x126>
     d18:	0040      	lsls	r0, r0, #1
     d1a:	bf28      	it	cs
     d1c:	f040 4000 	orrcs.w	r0, r0, #2147483648	; 0x80000000
     d20:	4770      	bx	lr
     d22:	f112 7200 	adds.w	r2, r2, #33554432	; 0x2000000
     d26:	bf3c      	itt	cc
     d28:	f500 0000 	addcc.w	r0, r0, #8388608	; 0x800000
     d2c:	4770      	bxcc	lr
     d2e:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     d32:	f043 40fe 	orr.w	r0, r3, #2130706432	; 0x7f000000
     d36:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     d3a:	4770      	bx	lr
     d3c:	ea7f 6222 	mvns.w	r2, r2, asr #24
     d40:	bf16      	itet	ne
     d42:	4608      	movne	r0, r1
     d44:	ea7f 6323 	mvnseq.w	r3, r3, asr #24
     d48:	4601      	movne	r1, r0
     d4a:	0242      	lsls	r2, r0, #9
     d4c:	bf06      	itte	eq
     d4e:	ea5f 2341 	movseq.w	r3, r1, lsl #9
     d52:	ea90 0f01 	teqeq	r0, r1
     d56:	f440 0080 	orrne.w	r0, r0, #4194304	; 0x400000
     d5a:	4770      	bx	lr

00000d5c <__aeabi_ui2f>:
     d5c:	f04f 0300 	mov.w	r3, #0
     d60:	e004      	b.n	d6c <__aeabi_i2f+0x8>
     d62:	bf00      	nop

00000d64 <__aeabi_i2f>:
     d64:	f010 4300 	ands.w	r3, r0, #2147483648	; 0x80000000
     d68:	bf48      	it	mi
     d6a:	4240      	negmi	r0, r0
     d6c:	ea5f 0c00 	movs.w	ip, r0
     d70:	bf08      	it	eq
     d72:	4770      	bxeq	lr
     d74:	f043 4396 	orr.w	r3, r3, #1258291200	; 0x4b000000
     d78:	4601      	mov	r1, r0
     d7a:	f04f 0000 	mov.w	r0, #0
     d7e:	e01c      	b.n	dba <__aeabi_l2f+0x2a>

00000d80 <__aeabi_ul2f>:
     d80:	ea50 0201 	orrs.w	r2, r0, r1
     d84:	bf08      	it	eq
     d86:	4770      	bxeq	lr
     d88:	f04f 0300 	mov.w	r3, #0
     d8c:	e00a      	b.n	da4 <__aeabi_l2f+0x14>
     d8e:	bf00      	nop

00000d90 <__aeabi_l2f>:
     d90:	ea50 0201 	orrs.w	r2, r0, r1
     d94:	bf08      	it	eq
     d96:	4770      	bxeq	lr
     d98:	f011 4300 	ands.w	r3, r1, #2147483648	; 0x80000000
     d9c:	d502      	bpl.n	da4 <__aeabi_l2f+0x14>
     d9e:	4240      	negs	r0, r0
     da0:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     da4:	ea5f 0c01 	movs.w	ip, r1
     da8:	bf02      	ittt	eq
     daa:	4684      	moveq	ip, r0
     dac:	4601      	moveq	r1, r0
     dae:	2000      	moveq	r0, #0
     db0:	f043 43b6 	orr.w	r3, r3, #1526726656	; 0x5b000000
     db4:	bf08      	it	eq
     db6:	f1a3 5380 	subeq.w	r3, r3, #268435456	; 0x10000000
     dba:	f5a3 0300 	sub.w	r3, r3, #8388608	; 0x800000
     dbe:	fabc f28c 	clz	r2, ip
     dc2:	3a08      	subs	r2, #8
     dc4:	eba3 53c2 	sub.w	r3, r3, r2, lsl #23
     dc8:	db10      	blt.n	dec <__aeabi_l2f+0x5c>
     dca:	fa01 fc02 	lsl.w	ip, r1, r2
     dce:	4463      	add	r3, ip
     dd0:	fa00 fc02 	lsl.w	ip, r0, r2
     dd4:	f1c2 0220 	rsb	r2, r2, #32
     dd8:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     ddc:	fa20 f202 	lsr.w	r2, r0, r2
     de0:	eb43 0002 	adc.w	r0, r3, r2
     de4:	bf08      	it	eq
     de6:	f020 0001 	biceq.w	r0, r0, #1
     dea:	4770      	bx	lr
     dec:	f102 0220 	add.w	r2, r2, #32
     df0:	fa01 fc02 	lsl.w	ip, r1, r2
     df4:	f1c2 0220 	rsb	r2, r2, #32
     df8:	ea50 004c 	orrs.w	r0, r0, ip, lsl #1
     dfc:	fa21 f202 	lsr.w	r2, r1, r2
     e00:	eb43 0002 	adc.w	r0, r3, r2
     e04:	bf08      	it	eq
     e06:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     e0a:	4770      	bx	lr

00000e0c <__aeabi_fmul>:
     e0c:	f04f 0cff 	mov.w	ip, #255	; 0xff
     e10:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     e14:	bf1e      	ittt	ne
     e16:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     e1a:	ea92 0f0c 	teqne	r2, ip
     e1e:	ea93 0f0c 	teqne	r3, ip
     e22:	d06f      	beq.n	f04 <__aeabi_fmul+0xf8>
     e24:	441a      	add	r2, r3
     e26:	ea80 0c01 	eor.w	ip, r0, r1
     e2a:	0240      	lsls	r0, r0, #9
     e2c:	bf18      	it	ne
     e2e:	ea5f 2141 	movsne.w	r1, r1, lsl #9
     e32:	d01e      	beq.n	e72 <__aeabi_fmul+0x66>
     e34:	f04f 6300 	mov.w	r3, #134217728	; 0x8000000
     e38:	ea43 1050 	orr.w	r0, r3, r0, lsr #5
     e3c:	ea43 1151 	orr.w	r1, r3, r1, lsr #5
     e40:	fba0 3101 	umull	r3, r1, r0, r1
     e44:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     e48:	f5b1 0f00 	cmp.w	r1, #8388608	; 0x800000
     e4c:	bf3e      	ittt	cc
     e4e:	0049      	lslcc	r1, r1, #1
     e50:	ea41 71d3 	orrcc.w	r1, r1, r3, lsr #31
     e54:	005b      	lslcc	r3, r3, #1
     e56:	ea40 0001 	orr.w	r0, r0, r1
     e5a:	f162 027f 	sbc.w	r2, r2, #127	; 0x7f
     e5e:	2afd      	cmp	r2, #253	; 0xfd
     e60:	d81d      	bhi.n	e9e <__aeabi_fmul+0x92>
     e62:	f1b3 4f00 	cmp.w	r3, #2147483648	; 0x80000000
     e66:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     e6a:	bf08      	it	eq
     e6c:	f020 0001 	biceq.w	r0, r0, #1
     e70:	4770      	bx	lr
     e72:	f090 0f00 	teq	r0, #0
     e76:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
     e7a:	bf08      	it	eq
     e7c:	0249      	lsleq	r1, r1, #9
     e7e:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
     e82:	ea40 2051 	orr.w	r0, r0, r1, lsr #9
     e86:	3a7f      	subs	r2, #127	; 0x7f
     e88:	bfc2      	ittt	gt
     e8a:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
     e8e:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
     e92:	4770      	bxgt	lr
     e94:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     e98:	f04f 0300 	mov.w	r3, #0
     e9c:	3a01      	subs	r2, #1
     e9e:	dc5d      	bgt.n	f5c <__aeabi_fmul+0x150>
     ea0:	f112 0f19 	cmn.w	r2, #25
     ea4:	bfdc      	itt	le
     ea6:	f000 4000 	andle.w	r0, r0, #2147483648	; 0x80000000
     eaa:	4770      	bxle	lr
     eac:	f1c2 0200 	rsb	r2, r2, #0
     eb0:	0041      	lsls	r1, r0, #1
     eb2:	fa21 f102 	lsr.w	r1, r1, r2
     eb6:	f1c2 0220 	rsb	r2, r2, #32
     eba:	fa00 fc02 	lsl.w	ip, r0, r2
     ebe:	ea5f 0031 	movs.w	r0, r1, rrx
     ec2:	f140 0000 	adc.w	r0, r0, #0
     ec6:	ea53 034c 	orrs.w	r3, r3, ip, lsl #1
     eca:	bf08      	it	eq
     ecc:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     ed0:	4770      	bx	lr
     ed2:	f092 0f00 	teq	r2, #0
     ed6:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
     eda:	bf02      	ittt	eq
     edc:	0040      	lsleq	r0, r0, #1
     ede:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
     ee2:	3a01      	subeq	r2, #1
     ee4:	d0f9      	beq.n	eda <__aeabi_fmul+0xce>
     ee6:	ea40 000c 	orr.w	r0, r0, ip
     eea:	f093 0f00 	teq	r3, #0
     eee:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
     ef2:	bf02      	ittt	eq
     ef4:	0049      	lsleq	r1, r1, #1
     ef6:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
     efa:	3b01      	subeq	r3, #1
     efc:	d0f9      	beq.n	ef2 <__aeabi_fmul+0xe6>
     efe:	ea41 010c 	orr.w	r1, r1, ip
     f02:	e78f      	b.n	e24 <__aeabi_fmul+0x18>
     f04:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
     f08:	ea92 0f0c 	teq	r2, ip
     f0c:	bf18      	it	ne
     f0e:	ea93 0f0c 	teqne	r3, ip
     f12:	d00a      	beq.n	f2a <__aeabi_fmul+0x11e>
     f14:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
     f18:	bf18      	it	ne
     f1a:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
     f1e:	d1d8      	bne.n	ed2 <__aeabi_fmul+0xc6>
     f20:	ea80 0001 	eor.w	r0, r0, r1
     f24:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f28:	4770      	bx	lr
     f2a:	f090 0f00 	teq	r0, #0
     f2e:	bf17      	itett	ne
     f30:	f090 4f00 	teqne	r0, #2147483648	; 0x80000000
     f34:	4608      	moveq	r0, r1
     f36:	f091 0f00 	teqne	r1, #0
     f3a:	f091 4f00 	teqne	r1, #2147483648	; 0x80000000
     f3e:	d014      	beq.n	f6a <__aeabi_fmul+0x15e>
     f40:	ea92 0f0c 	teq	r2, ip
     f44:	d101      	bne.n	f4a <__aeabi_fmul+0x13e>
     f46:	0242      	lsls	r2, r0, #9
     f48:	d10f      	bne.n	f6a <__aeabi_fmul+0x15e>
     f4a:	ea93 0f0c 	teq	r3, ip
     f4e:	d103      	bne.n	f58 <__aeabi_fmul+0x14c>
     f50:	024b      	lsls	r3, r1, #9
     f52:	bf18      	it	ne
     f54:	4608      	movne	r0, r1
     f56:	d108      	bne.n	f6a <__aeabi_fmul+0x15e>
     f58:	ea80 0001 	eor.w	r0, r0, r1
     f5c:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f60:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f64:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     f68:	4770      	bx	lr
     f6a:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f6e:	f440 0040 	orr.w	r0, r0, #12582912	; 0xc00000
     f72:	4770      	bx	lr

00000f74 <__aeabi_fdiv>:
     f74:	f04f 0cff 	mov.w	ip, #255	; 0xff
     f78:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     f7c:	bf1e      	ittt	ne
     f7e:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     f82:	ea92 0f0c 	teqne	r2, ip
     f86:	ea93 0f0c 	teqne	r3, ip
     f8a:	d069      	beq.n	1060 <__aeabi_fdiv+0xec>
     f8c:	eba2 0203 	sub.w	r2, r2, r3
     f90:	ea80 0c01 	eor.w	ip, r0, r1
     f94:	0249      	lsls	r1, r1, #9
     f96:	ea4f 2040 	mov.w	r0, r0, lsl #9
     f9a:	d037      	beq.n	100c <__aeabi_fdiv+0x98>
     f9c:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
     fa0:	ea43 1111 	orr.w	r1, r3, r1, lsr #4
     fa4:	ea43 1310 	orr.w	r3, r3, r0, lsr #4
     fa8:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     fac:	428b      	cmp	r3, r1
     fae:	bf38      	it	cc
     fb0:	005b      	lslcc	r3, r3, #1
     fb2:	f142 027d 	adc.w	r2, r2, #125	; 0x7d
     fb6:	f44f 0c00 	mov.w	ip, #8388608	; 0x800000
     fba:	428b      	cmp	r3, r1
     fbc:	bf24      	itt	cs
     fbe:	1a5b      	subcs	r3, r3, r1
     fc0:	ea40 000c 	orrcs.w	r0, r0, ip
     fc4:	ebb3 0f51 	cmp.w	r3, r1, lsr #1
     fc8:	bf24      	itt	cs
     fca:	eba3 0351 	subcs.w	r3, r3, r1, lsr #1
     fce:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     fd2:	ebb3 0f91 	cmp.w	r3, r1, lsr #2
     fd6:	bf24      	itt	cs
     fd8:	eba3 0391 	subcs.w	r3, r3, r1, lsr #2
     fdc:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     fe0:	ebb3 0fd1 	cmp.w	r3, r1, lsr #3
     fe4:	bf24      	itt	cs
     fe6:	eba3 03d1 	subcs.w	r3, r3, r1, lsr #3
     fea:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     fee:	011b      	lsls	r3, r3, #4
     ff0:	bf18      	it	ne
     ff2:	ea5f 1c1c 	movsne.w	ip, ip, lsr #4
     ff6:	d1e0      	bne.n	fba <__aeabi_fdiv+0x46>
     ff8:	2afd      	cmp	r2, #253	; 0xfd
     ffa:	f63f af50 	bhi.w	e9e <__aeabi_fmul+0x92>
     ffe:	428b      	cmp	r3, r1
    1000:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
    1004:	bf08      	it	eq
    1006:	f020 0001 	biceq.w	r0, r0, #1
    100a:	4770      	bx	lr
    100c:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
    1010:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
    1014:	327f      	adds	r2, #127	; 0x7f
    1016:	bfc2      	ittt	gt
    1018:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
    101c:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
    1020:	4770      	bxgt	lr
    1022:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
    1026:	f04f 0300 	mov.w	r3, #0
    102a:	3a01      	subs	r2, #1
    102c:	e737      	b.n	e9e <__aeabi_fmul+0x92>
    102e:	f092 0f00 	teq	r2, #0
    1032:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
    1036:	bf02      	ittt	eq
    1038:	0040      	lsleq	r0, r0, #1
    103a:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
    103e:	3a01      	subeq	r2, #1
    1040:	d0f9      	beq.n	1036 <__aeabi_fdiv+0xc2>
    1042:	ea40 000c 	orr.w	r0, r0, ip
    1046:	f093 0f00 	teq	r3, #0
    104a:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
    104e:	bf02      	ittt	eq
    1050:	0049      	lsleq	r1, r1, #1
    1052:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
    1056:	3b01      	subeq	r3, #1
    1058:	d0f9      	beq.n	104e <__aeabi_fdiv+0xda>
    105a:	ea41 010c 	orr.w	r1, r1, ip
    105e:	e795      	b.n	f8c <__aeabi_fdiv+0x18>
    1060:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
    1064:	ea92 0f0c 	teq	r2, ip
    1068:	d108      	bne.n	107c <__aeabi_fdiv+0x108>
    106a:	0242      	lsls	r2, r0, #9
    106c:	f47f af7d 	bne.w	f6a <__aeabi_fmul+0x15e>
    1070:	ea93 0f0c 	teq	r3, ip
    1074:	f47f af70 	bne.w	f58 <__aeabi_fmul+0x14c>
    1078:	4608      	mov	r0, r1
    107a:	e776      	b.n	f6a <__aeabi_fmul+0x15e>
    107c:	ea93 0f0c 	teq	r3, ip
    1080:	d104      	bne.n	108c <__aeabi_fdiv+0x118>
    1082:	024b      	lsls	r3, r1, #9
    1084:	f43f af4c 	beq.w	f20 <__aeabi_fmul+0x114>
    1088:	4608      	mov	r0, r1
    108a:	e76e      	b.n	f6a <__aeabi_fmul+0x15e>
    108c:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
    1090:	bf18      	it	ne
    1092:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
    1096:	d1ca      	bne.n	102e <__aeabi_fdiv+0xba>
    1098:	f030 4200 	bics.w	r2, r0, #2147483648	; 0x80000000
    109c:	f47f af5c 	bne.w	f58 <__aeabi_fmul+0x14c>
    10a0:	f031 4300 	bics.w	r3, r1, #2147483648	; 0x80000000
    10a4:	f47f af3c 	bne.w	f20 <__aeabi_fmul+0x114>
    10a8:	e75f      	b.n	f6a <__aeabi_fmul+0x15e>
    10aa:	bf00      	nop

000010ac <strcmp>:
    10ac:	ea80 0c01 	eor.w	ip, r0, r1
    10b0:	f01c 0f03 	tst.w	ip, #3
    10b4:	d137      	bne.n	1126 <strcmp+0x7a>
    10b6:	f010 0c03 	ands.w	ip, r0, #3
    10ba:	f020 0003 	bic.w	r0, r0, #3
    10be:	f021 0103 	bic.w	r1, r1, #3
    10c2:	f850 2b04 	ldr.w	r2, [r0], #4
    10c6:	bf08      	it	eq
    10c8:	f851 3b04 	ldreq.w	r3, [r1], #4
    10cc:	d00e      	beq.n	10ec <strcmp+0x40>
    10ce:	f08c 0c03 	eor.w	ip, ip, #3
    10d2:	f06f 437f 	mvn.w	r3, #4278190080	; 0xff000000
    10d6:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    10da:	fa23 fc0c 	lsr.w	ip, r3, ip
    10de:	f851 3b04 	ldr.w	r3, [r1], #4
    10e2:	ea42 020c 	orr.w	r2, r2, ip
    10e6:	ea43 030c 	orr.w	r3, r3, ip
    10ea:	bf00      	nop
    10ec:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    10f0:	429a      	cmp	r2, r3
    10f2:	bf01      	itttt	eq
    10f4:	ea2c 0c02 	biceq.w	ip, ip, r2
    10f8:	f01c 3f80 	tsteq.w	ip, #2155905152	; 0x80808080
    10fc:	f850 2b04 	ldreq.w	r2, [r0], #4
    1100:	f851 3b04 	ldreq.w	r3, [r1], #4
    1104:	d0f2      	beq.n	10ec <strcmp+0x40>
    1106:	ea4f 6002 	mov.w	r0, r2, lsl #24
    110a:	ea4f 2212 	mov.w	r2, r2, lsr #8
    110e:	2801      	cmp	r0, #1
    1110:	bf28      	it	cs
    1112:	ebb0 6f03 	cmpcs.w	r0, r3, lsl #24
    1116:	bf08      	it	eq
    1118:	0a1b      	lsreq	r3, r3, #8
    111a:	d0f4      	beq.n	1106 <strcmp+0x5a>
    111c:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    1120:	0e00      	lsrs	r0, r0, #24
    1122:	1ac0      	subs	r0, r0, r3
    1124:	4770      	bx	lr
    1126:	f010 0f03 	tst.w	r0, #3
    112a:	d00a      	beq.n	1142 <strcmp+0x96>
    112c:	f810 2b01 	ldrb.w	r2, [r0], #1
    1130:	f811 3b01 	ldrb.w	r3, [r1], #1
    1134:	2a01      	cmp	r2, #1
    1136:	bf28      	it	cs
    1138:	429a      	cmpcs	r2, r3
    113a:	d0f4      	beq.n	1126 <strcmp+0x7a>
    113c:	eba2 0003 	sub.w	r0, r2, r3
    1140:	4770      	bx	lr
    1142:	f84d 5d04 	str.w	r5, [sp, #-4]!
    1146:	f850 2b04 	ldr.w	r2, [r0], #4
    114a:	f001 0503 	and.w	r5, r1, #3
    114e:	f021 0103 	bic.w	r1, r1, #3
    1152:	f851 3b04 	ldr.w	r3, [r1], #4
    1156:	2d02      	cmp	r5, #2
    1158:	d026      	beq.n	11a8 <strcmp+0xfc>
    115a:	d84d      	bhi.n	11f8 <strcmp+0x14c>
    115c:	f022 457f 	bic.w	r5, r2, #4278190080	; 0xff000000
    1160:	ebb5 2f13 	cmp.w	r5, r3, lsr #8
    1164:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1168:	ea2c 0c02 	bic.w	ip, ip, r2
    116c:	d10d      	bne.n	118a <strcmp+0xde>
    116e:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    1172:	bf08      	it	eq
    1174:	f851 3b04 	ldreq.w	r3, [r1], #4
    1178:	d10a      	bne.n	1190 <strcmp+0xe4>
    117a:	ea85 0502 	eor.w	r5, r5, r2
    117e:	ebb5 6f03 	cmp.w	r5, r3, lsl #24
    1182:	d10c      	bne.n	119e <strcmp+0xf2>
    1184:	f850 2b04 	ldr.w	r2, [r0], #4
    1188:	e7e8      	b.n	115c <strcmp+0xb0>
    118a:	ea4f 2313 	mov.w	r3, r3, lsr #8
    118e:	e05b      	b.n	1248 <strcmp+0x19c>
    1190:	f03c 4c7f 	bics.w	ip, ip, #4278190080	; 0xff000000
    1194:	d154      	bne.n	1240 <strcmp+0x194>
    1196:	780b      	ldrb	r3, [r1, #0]
    1198:	ea4f 6512 	mov.w	r5, r2, lsr #24
    119c:	e054      	b.n	1248 <strcmp+0x19c>
    119e:	ea4f 6512 	mov.w	r5, r2, lsr #24
    11a2:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    11a6:	e04f      	b.n	1248 <strcmp+0x19c>
    11a8:	ea4f 4502 	mov.w	r5, r2, lsl #16
    11ac:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    11b0:	ea4f 4515 	mov.w	r5, r5, lsr #16
    11b4:	ea2c 0c02 	bic.w	ip, ip, r2
    11b8:	ebb5 4f13 	cmp.w	r5, r3, lsr #16
    11bc:	d118      	bne.n	11f0 <strcmp+0x144>
    11be:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    11c2:	bf08      	it	eq
    11c4:	f851 3b04 	ldreq.w	r3, [r1], #4
    11c8:	d107      	bne.n	11da <strcmp+0x12e>
    11ca:	ea85 0502 	eor.w	r5, r5, r2
    11ce:	ebb5 4f03 	cmp.w	r5, r3, lsl #16
    11d2:	d109      	bne.n	11e8 <strcmp+0x13c>
    11d4:	f850 2b04 	ldr.w	r2, [r0], #4
    11d8:	e7e6      	b.n	11a8 <strcmp+0xfc>
    11da:	ea5f 4c0c 	movs.w	ip, ip, lsl #16
    11de:	d12f      	bne.n	1240 <strcmp+0x194>
    11e0:	880b      	ldrh	r3, [r1, #0]
    11e2:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11e6:	e02f      	b.n	1248 <strcmp+0x19c>
    11e8:	ea4f 4303 	mov.w	r3, r3, lsl #16
    11ec:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11f0:	ea4f 4313 	mov.w	r3, r3, lsr #16
    11f4:	e028      	b.n	1248 <strcmp+0x19c>
    11f6:	bf00      	nop
    11f8:	f002 05ff 	and.w	r5, r2, #255	; 0xff
    11fc:	ebb5 6f13 	cmp.w	r5, r3, lsr #24
    1200:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1204:	ea2c 0c02 	bic.w	ip, ip, r2
    1208:	d10d      	bne.n	1226 <strcmp+0x17a>
    120a:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    120e:	bf08      	it	eq
    1210:	f851 3b04 	ldreq.w	r3, [r1], #4
    1214:	d10a      	bne.n	122c <strcmp+0x180>
    1216:	ea85 0502 	eor.w	r5, r5, r2
    121a:	ebb5 2f03 	cmp.w	r5, r3, lsl #8
    121e:	d10a      	bne.n	1236 <strcmp+0x18a>
    1220:	f850 2b04 	ldr.w	r2, [r0], #4
    1224:	e7e8      	b.n	11f8 <strcmp+0x14c>
    1226:	ea4f 6313 	mov.w	r3, r3, lsr #24
    122a:	e00d      	b.n	1248 <strcmp+0x19c>
    122c:	f012 0fff 	tst.w	r2, #255	; 0xff
    1230:	d006      	beq.n	1240 <strcmp+0x194>
    1232:	f851 3b04 	ldr.w	r3, [r1], #4
    1236:	ea4f 2512 	mov.w	r5, r2, lsr #8
    123a:	f023 437f 	bic.w	r3, r3, #4278190080	; 0xff000000
    123e:	e003      	b.n	1248 <strcmp+0x19c>
    1240:	f04f 0000 	mov.w	r0, #0
    1244:	bc20      	pop	{r5}
    1246:	4770      	bx	lr
    1248:	f005 02ff 	and.w	r2, r5, #255	; 0xff
    124c:	f003 00ff 	and.w	r0, r3, #255	; 0xff
    1250:	2801      	cmp	r0, #1
    1252:	bf28      	it	cs
    1254:	4290      	cmpcs	r0, r2
    1256:	bf04      	itt	eq
    1258:	0a2d      	lsreq	r5, r5, #8
    125a:	0a1b      	lsreq	r3, r3, #8
    125c:	d0f4      	beq.n	1248 <strcmp+0x19c>
    125e:	eba2 0000 	sub.w	r0, r2, r0
    1262:	bc20      	pop	{r5}
    1264:	4770      	bx	lr
    1266:	bf00      	nop

Disassembly of section .text.arm_Init:

00001268 <arm_Init>:
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    1268:	4b3e      	ldr	r3, [pc, #248]	; (1364 <arm_Init+0xfc>)
    126a:	2000      	movs	r0, #0

// -----------------------------------------------------------------------------------------------
// Descrição:	Incialiaza clock do processador e dos barramentos através do STARTUP
// ajustes no makefile 	
// -----------------------------------------------------------------------------------------------
void arm_Init (void) {
    126c:	b570      	push	{r4, r5, r6, lr}
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    126e:	6018      	str	r0, [r3, #0]
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1270:	4b3d      	ldr	r3, [pc, #244]	; (1368 <arm_Init+0x100>)
    1272:	f44f 4200 	mov.w	r2, #32768	; 0x8000
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    1276:	493d      	ldr	r1, [pc, #244]	; (136c <arm_Init+0x104>)
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1278:	601a      	str	r2, [r3, #0]
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127a:	680b      	ldr	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    127c:	4a3c      	ldr	r2, [pc, #240]	; (1370 <arm_Init+0x108>)
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127e:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    1282:	f043 0301 	orr.w	r3, r3, #1
    1286:	600b      	str	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    1288:	4b3a      	ldr	r3, [pc, #232]	; (1374 <arm_Init+0x10c>)
	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    128a:	6010      	str	r0, [r2, #0]
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    128c:	6818      	ldr	r0, [r3, #0]
    128e:	f020 0020 	bic.w	r0, r0, #32
    1292:	6018      	str	r0, [r3, #0]
	#if (F_CPU > 20000000)
	SCS |= SCS_OSCRANGE_15MHZ_25MHZ;
	#endif
  	scs_oscON();							// Liga o oscilador MAIN
    1294:	6818      	ldr	r0, [r3, #0]
    1296:	f040 0020 	orr.w	r0, r0, #32
    129a:	6018      	str	r0, [r3, #0]
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
    129c:	6818      	ldr	r0, [r3, #0]
    129e:	0640      	lsls	r0, r0, #25
    12a0:	d5fc      	bpl.n	129c <arm_Init+0x34>
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
    12a2:	2301      	movs	r3, #1
    12a4:	6013      	str	r3, [r2, #0]
  	#endif

  	pll_OFF(); 								// Desabilita PLL
    12a6:	4a34      	ldr	r2, [pc, #208]	; (1378 <arm_Init+0x110>)
    12a8:	2300      	movs	r3, #0
    12aa:	6013      	str	r3, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ac:	4d33      	ldr	r5, [pc, #204]	; (137c <arm_Init+0x114>)
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ae:	4b34      	ldr	r3, [pc, #208]	; (1380 <arm_Init+0x118>)
    12b0:	24aa      	movs	r4, #170	; 0xaa
    12b2:	2055      	movs	r0, #85	; 0x55
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12b4:	260e      	movs	r6, #14
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12b6:	601c      	str	r4, [r3, #0]
    12b8:	6018      	str	r0, [r3, #0]
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ba:	602e      	str	r6, [r5, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12bc:	601c      	str	r4, [r3, #0]
    12be:	6018      	str	r0, [r3, #0]
  	pll_ON();								// Habilita PLL
    12c0:	6815      	ldr	r5, [r2, #0]
    12c2:	f045 0501 	orr.w	r5, r5, #1
    12c6:	6015      	str	r5, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12c8:	4d2e      	ldr	r5, [pc, #184]	; (1384 <arm_Init+0x11c>)
  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll_ON();								// Habilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ca:	601c      	str	r4, [r3, #0]
    12cc:	6018      	str	r0, [r3, #0]

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12ce:	6828      	ldr	r0, [r5, #0]
    12d0:	4c2c      	ldr	r4, [pc, #176]	; (1384 <arm_Init+0x11c>)
    12d2:	f010 6f80 	tst.w	r0, #67108864	; 0x4000000
    12d6:	d0fa      	beq.n	12ce <arm_Init+0x66>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll_Connect();							// Conecta PLL
    12d8:	6810      	ldr	r0, [r2, #0]
    12da:	f040 0002 	orr.w	r0, r0, #2
    12de:	6010      	str	r0, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12e0:	22aa      	movs	r2, #170	; 0xaa
    12e2:	601a      	str	r2, [r3, #0]
    12e4:	2255      	movs	r2, #85	; 0x55
    12e6:	601a      	str	r2, [r3, #0]
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
    12e8:	6823      	ldr	r3, [r4, #0]
    12ea:	019a      	lsls	r2, r3, #6
    12ec:	d5fc      	bpl.n	12e8 <arm_Init+0x80>
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
    12ee:	4a26      	ldr	r2, [pc, #152]	; (1388 <arm_Init+0x120>)
    12f0:	2300      	movs	r3, #0
    12f2:	6013      	str	r3, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12f4:	4d25      	ldr	r5, [pc, #148]	; (138c <arm_Init+0x124>)
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12f6:	4b26      	ldr	r3, [pc, #152]	; (1390 <arm_Init+0x128>)
    12f8:	24aa      	movs	r4, #170	; 0xaa
    12fa:	2055      	movs	r0, #85	; 0x55
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12fc:	2607      	movs	r6, #7
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12fe:	601c      	str	r4, [r3, #0]
    1300:	6018      	str	r0, [r3, #0]
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    1302:	602e      	str	r6, [r5, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1304:	601c      	str	r4, [r3, #0]
    1306:	6018      	str	r0, [r3, #0]
  	pll1_ON();								// Habilita PLL
    1308:	6815      	ldr	r5, [r2, #0]
    130a:	f045 0501 	orr.w	r5, r5, #1
    130e:	6015      	str	r5, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1310:	4d20      	ldr	r5, [pc, #128]	; (1394 <arm_Init+0x12c>)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll1_ON();								// Habilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1312:	601c      	str	r4, [r3, #0]
    1314:	6018      	str	r0, [r3, #0]

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1316:	6828      	ldr	r0, [r5, #0]
    1318:	4c1e      	ldr	r4, [pc, #120]	; (1394 <arm_Init+0x12c>)
    131a:	f410 6f80 	tst.w	r0, #1024	; 0x400
    131e:	d0fa      	beq.n	1316 <arm_Init+0xae>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll1_Connect();							// Conecta PLL
    1320:	6810      	ldr	r0, [r2, #0]
    1322:	f040 0002 	orr.w	r0, r0, #2
    1326:	6010      	str	r0, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1328:	22aa      	movs	r2, #170	; 0xaa
    132a:	601a      	str	r2, [r3, #0]
    132c:	2255      	movs	r2, #85	; 0x55
    132e:	601a      	str	r2, [r3, #0]
	while (!(PLL1STAT & PLL1STAT_PLLC));	// Espera que o PLL se conecte ao sistema
    1330:	6823      	ldr	r3, [r4, #0]
    1332:	059b      	lsls	r3, r3, #22
    1334:	d5fc      	bpl.n	1330 <arm_Init+0xc8>
  	#endif
  	usbksel_clkDiv(USBCLKDIV);				// Aplicar divisor obter o USBCLK do PLL1_OUT
    1336:	4a18      	ldr	r2, [pc, #96]	; (1398 <arm_Init+0x130>)
    1338:	6813      	ldr	r3, [r2, #0]
    133a:	f023 030f 	bic.w	r3, r3, #15
    133e:	f043 0301 	orr.w	r3, r3, #1
    1342:	6013      	str	r3, [r2, #0]
  	#endif

  	cclksel_clkDiv(CCLKDIV);				// Aplicar divisor obter o CCLK do PLL_OUT
    1344:	680b      	ldr	r3, [r1, #0]
    1346:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    134a:	f043 0302 	orr.w	r3, r3, #2
    134e:	600b      	str	r3, [r1, #0]
		// Pclk roda 1/2 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL  = 0xaaa2a2aa;
  		PCLKSEL1 = 0xa8aaa8aa;
	#elif ((CCLK / PCLK) == 4)
		// Pclk roda 1/4 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL = 0x0;
    1350:	2300      	movs	r3, #0
    1352:	f8c2 30a0 	str.w	r3, [r2, #160]	; 0xa0
  		PCLKSEL1 = 0x0;
    1356:	f8c2 30a4 	str.w	r3, [r2, #164]	; 0xa4
	// O power boost (PBOOST) é ativado após o reset, permitindo trabalhar com frequencia da CPU de até
	//	seu limite máximo. Vamos deixar desse modo, mas se usar gestão de economia de energia teremos
	//	que rever isto
	#if (FLASHTIM == FLASHTIM_AUTO)
		#if (CCLK >= 100000000)
		FLASHCFG = FLASHTIM_100MHZ | 0x3a; // definir a velocidade de acesso a flash (consulte _config_cpu_.h)
    135a:	f244 023a 	movw	r2, #16442	; 0x403a
    135e:	4b0f      	ldr	r3, [pc, #60]	; (139c <arm_Init+0x134>)
    1360:	601a      	str	r2, [r3, #0]
    1362:	bd70      	pop	{r4, r5, r6, pc}
    1364:	e000ed08 	.word	0xe000ed08
    1368:	400fc0c4 	.word	0x400fc0c4
    136c:	400fc104 	.word	0x400fc104
    1370:	400fc10c 	.word	0x400fc10c
    1374:	400fc1a0 	.word	0x400fc1a0
    1378:	400fc080 	.word	0x400fc080
    137c:	400fc084 	.word	0x400fc084
    1380:	400fc08c 	.word	0x400fc08c
    1384:	400fc088 	.word	0x400fc088
    1388:	400fc0a0 	.word	0x400fc0a0
    138c:	400fc0a4 	.word	0x400fc0a4
    1390:	400fc0ac 	.word	0x400fc0ac
    1394:	400fc0a8 	.word	0x400fc0a8
    1398:	400fc108 	.word	0x400fc108
    139c:	400fc000 	.word	0x400fc000

Disassembly of section .text._start:

000013a0 <_start>:
#endif


// ESTA FUNÇÃO É CHAMADA PELO VETOR DE INTERRUPÇÃO RESET
void _start (void);
void _start (void) {
    13a0:	b508      	push	{r3, lr}
	// DESABILITA TODAS AS INTERRUPÇÕES
	irq_Disable();
    13a2:	b672      	cpsid	i
	// -------------------------------------------------------------------------------------------------------------------------
	// CONFIGURA PROCESSADOR ARM
	// 	As configurações do arm deve ser feita antes, isto porque em algumas configurações abaixo
	//	 necessitam de delays para inicializações baseadas na frequencia do processador
	// -------------------------------------------------------------------------------------------------------------------------
	arm_Init();
    13a4:	f7ff ff60 	bl	1268 <arm_Init>
    13a8:	4a0a      	ldr	r2, [pc, #40]	; (13d4 <_start+0x34>)
    13aa:	4b0b      	ldr	r3, [pc, #44]	; (13d8 <_start+0x38>)
	// ATRIBUI OS VALORES INICIAIS DAS VARIÁVEIS DA SECÇÃO .data
	// -------------------------------------------------------------------------------------------------------------------------
	#if defined(RUN_MODE1) || defined(RUN_MODE2) || defined (RUN_MODEBOOT1) || defined (RUN_MODEBOOT2)
	pSrc  = &_etext; 		// Captura o endereço final da secção .text e .rodata. Onde contém os valores da variáveis inicializadas
	pDest = &_data;			// Captura o endereço inicial da área de RAM da secção .data (variáveis inicializadas)
	while(pDest < &_edata)	// Faça até o endereço final da área de RAM da secção .data
    13ac:	490b      	ldr	r1, [pc, #44]	; (13dc <_start+0x3c>)
    13ae:	428b      	cmp	r3, r1
    13b0:	d204      	bcs.n	13bc <_start+0x1c>
		*pDest++ = *pSrc++;
    13b2:	f852 0f04 	ldr.w	r0, [r2, #4]!
    13b6:	f843 0b04 	str.w	r0, [r3], #4
    13ba:	e7f8      	b.n	13ae <_start+0xe>
    13bc:	4b08      	ldr	r3, [pc, #32]	; (13e0 <_start+0x40>)

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13be:	4a09      	ldr	r2, [pc, #36]	; (13e4 <_start+0x44>)
		*pDest++ = 0;		// Limpa o endereço de memória
    13c0:	2100      	movs	r1, #0

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13c2:	4293      	cmp	r3, r2
    13c4:	d202      	bcs.n	13cc <_start+0x2c>
		*pDest++ = 0;		// Limpa o endereço de memória
    13c6:	f843 1b04 	str.w	r1, [r3], #4
    13ca:	e7fa      	b.n	13c2 <_start+0x22>


	// -------------------------------------------------------------------------------------------------------------------------
	// CHAMA O PROGRAMA MAIN SEM PASSAGEM DE PARAMETROS
	// -------------------------------------------------------------------------------------------------------------------------
	main();
    13cc:	f000 fda0 	bl	1f10 <main>
    13d0:	e7fe      	b.n	13d0 <_start+0x30>
    13d2:	bf00      	nop
    13d4:	000040e8 	.word	0x000040e8
    13d8:	10000000 	.word	0x10000000
    13dc:	100005d4 	.word	0x100005d4
    13e0:	100005d4 	.word	0x100005d4
    13e4:	10000868 	.word	0x10000868

Disassembly of section .text.nmi_ISR:

000013e8 <nmi_ISR>:
}; /* gVectors */

/*
 * And here are the weak interrupt handlers.
 */
void nmi_ISR (void) {
    13e8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr NMI");
    13ea:	4905      	ldr	r1, [pc, #20]	; (1400 <nmi_ISR+0x18>)
    13ec:	2002      	movs	r0, #2
    13ee:	f001 fbb5 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(1);
    13f2:	4b04      	ldr	r3, [pc, #16]	; (1404 <nmi_ISR+0x1c>)
    13f4:	681a      	ldr	r2, [r3, #0]
    13f6:	b112      	cbz	r2, 13fe <nmi_ISR+0x16>
    13f8:	681b      	ldr	r3, [r3, #0]
    13fa:	2001      	movs	r0, #1
    13fc:	4798      	blx	r3
    13fe:	e7fe      	b.n	13fe <nmi_ISR+0x16>
    1400:	00003888 	.word	0x00003888
    1404:	100005fc 	.word	0x100005fc

Disassembly of section .text.hardFault_ISR:

00001408 <hardFault_ISR>:
	while(1);
}

void hardFault_ISR (void) {
    1408:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr hardFault"CMD_TERMINATOR);
    140a:	490d      	ldr	r1, [pc, #52]	; (1440 <hardFault_ISR+0x38>)
    140c:	2002      	movs	r0, #2
    140e:	f001 fba5 	bl	2b5c <rprintf>
	plognp("Possiveis causas:"CMD_TERMINATOR);
    1412:	490c      	ldr	r1, [pc, #48]	; (1444 <hardFault_ISR+0x3c>)
    1414:	2002      	movs	r0, #2
    1416:	f001 fba1 	bl	2b5c <rprintf>
	plognp("  Acesso a memória inexistente, como acesso fora de um array"CMD_TERMINATOR);
    141a:	490b      	ldr	r1, [pc, #44]	; (1448 <hardFault_ISR+0x40>)
    141c:	2002      	movs	r0, #2
    141e:	f001 fb9d 	bl	2b5c <rprintf>
	plognp("  Acesso a um hardware não ligado ou com clock desligado"CMD_TERMINATOR);
    1422:	490a      	ldr	r1, [pc, #40]	; (144c <hardFault_ISR+0x44>)
    1424:	2002      	movs	r0, #2
    1426:	f001 fb99 	bl	2b5c <rprintf>
	plognp("  Registrador acessando pino I/O apontando para duas funções diferentes"CMD_TERMINATOR);
    142a:	4909      	ldr	r1, [pc, #36]	; (1450 <hardFault_ISR+0x48>)
    142c:	2002      	movs	r0, #2
    142e:	f001 fb95 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(2);
    1432:	4b08      	ldr	r3, [pc, #32]	; (1454 <hardFault_ISR+0x4c>)
    1434:	681a      	ldr	r2, [r3, #0]
    1436:	b112      	cbz	r2, 143e <hardFault_ISR+0x36>
    1438:	681b      	ldr	r3, [r3, #0]
    143a:	2002      	movs	r0, #2
    143c:	4798      	blx	r3
    143e:	e7fe      	b.n	143e <hardFault_ISR+0x36>
    1440:	00003893 	.word	0x00003893
    1444:	000038a5 	.word	0x000038a5
    1448:	000038b8 	.word	0x000038b8
    144c:	000038f6 	.word	0x000038f6
    1450:	00003930 	.word	0x00003930
    1454:	100005fc 	.word	0x100005fc

Disassembly of section .text.memManage_ISR:

00001458 <memManage_ISR>:
	while(1);
}
void memManage_ISR (void) {
    1458:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr memManage");
    145a:	4905      	ldr	r1, [pc, #20]	; (1470 <memManage_ISR+0x18>)
    145c:	2002      	movs	r0, #2
    145e:	f001 fb7d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(3);
    1462:	4b04      	ldr	r3, [pc, #16]	; (1474 <memManage_ISR+0x1c>)
    1464:	681a      	ldr	r2, [r3, #0]
    1466:	b112      	cbz	r2, 146e <memManage_ISR+0x16>
    1468:	681b      	ldr	r3, [r3, #0]
    146a:	2003      	movs	r0, #3
    146c:	4798      	blx	r3
    146e:	e7fe      	b.n	146e <memManage_ISR+0x16>
    1470:	00003979 	.word	0x00003979
    1474:	100005fc 	.word	0x100005fc

Disassembly of section .text.busFault_ISR:

00001478 <busFault_ISR>:
	while(1);
}
void busFault_ISR (void) {
    1478:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr busFault");
    147a:	4905      	ldr	r1, [pc, #20]	; (1490 <busFault_ISR+0x18>)
    147c:	2002      	movs	r0, #2
    147e:	f001 fb6d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(4);
    1482:	4b04      	ldr	r3, [pc, #16]	; (1494 <busFault_ISR+0x1c>)
    1484:	681a      	ldr	r2, [r3, #0]
    1486:	b112      	cbz	r2, 148e <busFault_ISR+0x16>
    1488:	681b      	ldr	r3, [r3, #0]
    148a:	2004      	movs	r0, #4
    148c:	4798      	blx	r3
    148e:	e7fe      	b.n	148e <busFault_ISR+0x16>
    1490:	0000398a 	.word	0x0000398a
    1494:	100005fc 	.word	0x100005fc

Disassembly of section .text.usageFault_ISR:

00001498 <usageFault_ISR>:
	while(1);
}
void usageFault_ISR (void) {
    1498:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usageFault_ISR");
    149a:	4905      	ldr	r1, [pc, #20]	; (14b0 <usageFault_ISR+0x18>)
    149c:	2002      	movs	r0, #2
    149e:	f001 fb5d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(5);
    14a2:	4b04      	ldr	r3, [pc, #16]	; (14b4 <usageFault_ISR+0x1c>)
    14a4:	681a      	ldr	r2, [r3, #0]
    14a6:	b112      	cbz	r2, 14ae <usageFault_ISR+0x16>
    14a8:	681b      	ldr	r3, [r3, #0]
    14aa:	2005      	movs	r0, #5
    14ac:	4798      	blx	r3
    14ae:	e7fe      	b.n	14ae <usageFault_ISR+0x16>
    14b0:	0000399a 	.word	0x0000399a
    14b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.svc_ISR:

000014b8 <svc_ISR>:
	while(1);
}
void svc_ISR (void) {
    14b8:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr svc");
    14ba:	4905      	ldr	r1, [pc, #20]	; (14d0 <svc_ISR+0x18>)
    14bc:	2002      	movs	r0, #2
    14be:	f001 fb4d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(6);
    14c2:	4b04      	ldr	r3, [pc, #16]	; (14d4 <svc_ISR+0x1c>)
    14c4:	681a      	ldr	r2, [r3, #0]
    14c6:	b112      	cbz	r2, 14ce <svc_ISR+0x16>
    14c8:	681b      	ldr	r3, [r3, #0]
    14ca:	2006      	movs	r0, #6
    14cc:	4798      	blx	r3
    14ce:	e7fe      	b.n	14ce <svc_ISR+0x16>
    14d0:	000039b0 	.word	0x000039b0
    14d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.debugMon_ISR:

000014d8 <debugMon_ISR>:
	while(1);
}
void debugMon_ISR (void) {
    14d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr debugMon");
    14da:	4905      	ldr	r1, [pc, #20]	; (14f0 <debugMon_ISR+0x18>)
    14dc:	2002      	movs	r0, #2
    14de:	f001 fb3d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(7);
    14e2:	4b04      	ldr	r3, [pc, #16]	; (14f4 <debugMon_ISR+0x1c>)
    14e4:	681a      	ldr	r2, [r3, #0]
    14e6:	b112      	cbz	r2, 14ee <debugMon_ISR+0x16>
    14e8:	681b      	ldr	r3, [r3, #0]
    14ea:	2007      	movs	r0, #7
    14ec:	4798      	blx	r3
    14ee:	e7fe      	b.n	14ee <debugMon_ISR+0x16>
    14f0:	000039bb 	.word	0x000039bb
    14f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pendSV_ISR:

000014f8 <pendSV_ISR>:
	while(1);
}
void pendSV_ISR (void) {
    14f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pendSV");
    14fa:	4905      	ldr	r1, [pc, #20]	; (1510 <pendSV_ISR+0x18>)
    14fc:	2002      	movs	r0, #2
    14fe:	f001 fb2d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(8);
    1502:	4b04      	ldr	r3, [pc, #16]	; (1514 <pendSV_ISR+0x1c>)
    1504:	681a      	ldr	r2, [r3, #0]
    1506:	b112      	cbz	r2, 150e <pendSV_ISR+0x16>
    1508:	681b      	ldr	r3, [r3, #0]
    150a:	2008      	movs	r0, #8
    150c:	4798      	blx	r3
    150e:	e7fe      	b.n	150e <pendSV_ISR+0x16>
    1510:	000039cb 	.word	0x000039cb
    1514:	100005fc 	.word	0x100005fc

Disassembly of section .text.wdt_ISR:

00001518 <wdt_ISR>:
	plognp("vicErr sysTick");
	#endif
	if (vicerr_Functions) vicerr_Functions(9);
	while(1);
}
void wdt_ISR (void) {
    1518:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr wdt");
    151a:	4905      	ldr	r1, [pc, #20]	; (1530 <wdt_ISR+0x18>)
    151c:	2002      	movs	r0, #2
    151e:	f001 fb1d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(10);
    1522:	4b04      	ldr	r3, [pc, #16]	; (1534 <wdt_ISR+0x1c>)
    1524:	681a      	ldr	r2, [r3, #0]
    1526:	b112      	cbz	r2, 152e <wdt_ISR+0x16>
    1528:	681b      	ldr	r3, [r3, #0]
    152a:	200a      	movs	r0, #10
    152c:	4798      	blx	r3
    152e:	e7fe      	b.n	152e <wdt_ISR+0x16>
    1530:	000039e8 	.word	0x000039e8
    1534:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer0_ISR:

00001538 <timer0_ISR>:
	while(1);
}
void timer0_ISR (void) {
    1538:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer0");
    153a:	4905      	ldr	r1, [pc, #20]	; (1550 <timer0_ISR+0x18>)
    153c:	2002      	movs	r0, #2
    153e:	f001 fb0d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(11);
    1542:	4b04      	ldr	r3, [pc, #16]	; (1554 <timer0_ISR+0x1c>)
    1544:	681a      	ldr	r2, [r3, #0]
    1546:	b112      	cbz	r2, 154e <timer0_ISR+0x16>
    1548:	681b      	ldr	r3, [r3, #0]
    154a:	200b      	movs	r0, #11
    154c:	4798      	blx	r3
    154e:	e7fe      	b.n	154e <timer0_ISR+0x16>
    1550:	000039f3 	.word	0x000039f3
    1554:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer1_ISR:

00001558 <timer1_ISR>:
	while(1);
}
void timer1_ISR (void) {
    1558:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer1");
    155a:	4905      	ldr	r1, [pc, #20]	; (1570 <timer1_ISR+0x18>)
    155c:	2002      	movs	r0, #2
    155e:	f001 fafd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(12);
    1562:	4b04      	ldr	r3, [pc, #16]	; (1574 <timer1_ISR+0x1c>)
    1564:	681a      	ldr	r2, [r3, #0]
    1566:	b112      	cbz	r2, 156e <timer1_ISR+0x16>
    1568:	681b      	ldr	r3, [r3, #0]
    156a:	200c      	movs	r0, #12
    156c:	4798      	blx	r3
    156e:	e7fe      	b.n	156e <timer1_ISR+0x16>
    1570:	00003a01 	.word	0x00003a01
    1574:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer2_ISR:

00001578 <timer2_ISR>:
	while(1);
}
void timer2_ISR (void) {
    1578:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer2");
    157a:	4905      	ldr	r1, [pc, #20]	; (1590 <timer2_ISR+0x18>)
    157c:	2002      	movs	r0, #2
    157e:	f001 faed 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(13);
    1582:	4b04      	ldr	r3, [pc, #16]	; (1594 <timer2_ISR+0x1c>)
    1584:	681a      	ldr	r2, [r3, #0]
    1586:	b112      	cbz	r2, 158e <timer2_ISR+0x16>
    1588:	681b      	ldr	r3, [r3, #0]
    158a:	200d      	movs	r0, #13
    158c:	4798      	blx	r3
    158e:	e7fe      	b.n	158e <timer2_ISR+0x16>
    1590:	00003a0f 	.word	0x00003a0f
    1594:	100005fc 	.word	0x100005fc

Disassembly of section .text.timer3_ISR:

00001598 <timer3_ISR>:
	while(1);
}
void timer3_ISR (void) {
    1598:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer3");
    159a:	4905      	ldr	r1, [pc, #20]	; (15b0 <timer3_ISR+0x18>)
    159c:	2002      	movs	r0, #2
    159e:	f001 fadd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(14);
    15a2:	4b04      	ldr	r3, [pc, #16]	; (15b4 <timer3_ISR+0x1c>)
    15a4:	681a      	ldr	r2, [r3, #0]
    15a6:	b112      	cbz	r2, 15ae <timer3_ISR+0x16>
    15a8:	681b      	ldr	r3, [r3, #0]
    15aa:	200e      	movs	r0, #14
    15ac:	4798      	blx	r3
    15ae:	e7fe      	b.n	15ae <timer3_ISR+0x16>
    15b0:	00003a1d 	.word	0x00003a1d
    15b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart1_ISR:

000015b8 <uart1_ISR>:
	plognp("vicErr uart0");
	#endif
	if (vicerr_Functions) vicerr_Functions(15);
	while(1);
}
void uart1_ISR (void) {
    15b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart1");
    15ba:	4905      	ldr	r1, [pc, #20]	; (15d0 <uart1_ISR+0x18>)
    15bc:	2002      	movs	r0, #2
    15be:	f001 facd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(16);
    15c2:	4b04      	ldr	r3, [pc, #16]	; (15d4 <uart1_ISR+0x1c>)
    15c4:	681a      	ldr	r2, [r3, #0]
    15c6:	b112      	cbz	r2, 15ce <uart1_ISR+0x16>
    15c8:	681b      	ldr	r3, [r3, #0]
    15ca:	2010      	movs	r0, #16
    15cc:	4798      	blx	r3
    15ce:	e7fe      	b.n	15ce <uart1_ISR+0x16>
    15d0:	00003a38 	.word	0x00003a38
    15d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart2_ISR:

000015d8 <uart2_ISR>:
	while(1);
}
void uart2_ISR (void) {
    15d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart2");
    15da:	4905      	ldr	r1, [pc, #20]	; (15f0 <uart2_ISR+0x18>)
    15dc:	2002      	movs	r0, #2
    15de:	f001 fabd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(17);
    15e2:	4b04      	ldr	r3, [pc, #16]	; (15f4 <uart2_ISR+0x1c>)
    15e4:	681a      	ldr	r2, [r3, #0]
    15e6:	b112      	cbz	r2, 15ee <uart2_ISR+0x16>
    15e8:	681b      	ldr	r3, [r3, #0]
    15ea:	2011      	movs	r0, #17
    15ec:	4798      	blx	r3
    15ee:	e7fe      	b.n	15ee <uart2_ISR+0x16>
    15f0:	00003a45 	.word	0x00003a45
    15f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart3_ISR:

000015f8 <uart3_ISR>:
	while(1);
}
void uart3_ISR (void) {
    15f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart3");
    15fa:	4905      	ldr	r1, [pc, #20]	; (1610 <uart3_ISR+0x18>)
    15fc:	2002      	movs	r0, #2
    15fe:	f001 faad 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(18);
    1602:	4b04      	ldr	r3, [pc, #16]	; (1614 <uart3_ISR+0x1c>)
    1604:	681a      	ldr	r2, [r3, #0]
    1606:	b112      	cbz	r2, 160e <uart3_ISR+0x16>
    1608:	681b      	ldr	r3, [r3, #0]
    160a:	2012      	movs	r0, #18
    160c:	4798      	blx	r3
    160e:	e7fe      	b.n	160e <uart3_ISR+0x16>
    1610:	00003a52 	.word	0x00003a52
    1614:	100005fc 	.word	0x100005fc

Disassembly of section .text.pwm_ISR:

00001618 <pwm_ISR>:
	while(1);
}
void pwm_ISR (void) {
    1618:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm");
    161a:	4905      	ldr	r1, [pc, #20]	; (1630 <pwm_ISR+0x18>)
    161c:	2002      	movs	r0, #2
    161e:	f001 fa9d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(19);
    1622:	4b04      	ldr	r3, [pc, #16]	; (1634 <pwm_ISR+0x1c>)
    1624:	681a      	ldr	r2, [r3, #0]
    1626:	b112      	cbz	r2, 162e <pwm_ISR+0x16>
    1628:	681b      	ldr	r3, [r3, #0]
    162a:	2013      	movs	r0, #19
    162c:	4798      	blx	r3
    162e:	e7fe      	b.n	162e <pwm_ISR+0x16>
    1630:	00003a5f 	.word	0x00003a5f
    1634:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c0_ISR:

00001638 <i2c0_ISR>:
	while(1);
}
void i2c0_ISR (void) {
    1638:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c0");
    163a:	4905      	ldr	r1, [pc, #20]	; (1650 <i2c0_ISR+0x18>)
    163c:	2002      	movs	r0, #2
    163e:	f001 fa8d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(20);
    1642:	4b04      	ldr	r3, [pc, #16]	; (1654 <i2c0_ISR+0x1c>)
    1644:	681a      	ldr	r2, [r3, #0]
    1646:	b112      	cbz	r2, 164e <i2c0_ISR+0x16>
    1648:	681b      	ldr	r3, [r3, #0]
    164a:	2014      	movs	r0, #20
    164c:	4798      	blx	r3
    164e:	e7fe      	b.n	164e <i2c0_ISR+0x16>
    1650:	00003a6a 	.word	0x00003a6a
    1654:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c1_ISR:

00001658 <i2c1_ISR>:
	while(1);
}
void i2c1_ISR (void) {
    1658:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c1");
    165a:	4905      	ldr	r1, [pc, #20]	; (1670 <i2c1_ISR+0x18>)
    165c:	2002      	movs	r0, #2
    165e:	f001 fa7d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(21);
    1662:	4b04      	ldr	r3, [pc, #16]	; (1674 <i2c1_ISR+0x1c>)
    1664:	681a      	ldr	r2, [r3, #0]
    1666:	b112      	cbz	r2, 166e <i2c1_ISR+0x16>
    1668:	681b      	ldr	r3, [r3, #0]
    166a:	2015      	movs	r0, #21
    166c:	4798      	blx	r3
    166e:	e7fe      	b.n	166e <i2c1_ISR+0x16>
    1670:	00003a76 	.word	0x00003a76
    1674:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2c2_ISR:

00001678 <i2c2_ISR>:
	while(1);
}
void i2c2_ISR (void) {
    1678:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c2");
    167a:	4905      	ldr	r1, [pc, #20]	; (1690 <i2c2_ISR+0x18>)
    167c:	2002      	movs	r0, #2
    167e:	f001 fa6d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(22);
    1682:	4b04      	ldr	r3, [pc, #16]	; (1694 <i2c2_ISR+0x1c>)
    1684:	681a      	ldr	r2, [r3, #0]
    1686:	b112      	cbz	r2, 168e <i2c2_ISR+0x16>
    1688:	681b      	ldr	r3, [r3, #0]
    168a:	2016      	movs	r0, #22
    168c:	4798      	blx	r3
    168e:	e7fe      	b.n	168e <i2c2_ISR+0x16>
    1690:	00003a82 	.word	0x00003a82
    1694:	100005fc 	.word	0x100005fc

Disassembly of section .text.spi_ISR:

00001698 <spi_ISR>:
	while(1);
}
void spi_ISR (void) {
    1698:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spi");
    169a:	4905      	ldr	r1, [pc, #20]	; (16b0 <spi_ISR+0x18>)
    169c:	2002      	movs	r0, #2
    169e:	f001 fa5d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(23);
    16a2:	4b04      	ldr	r3, [pc, #16]	; (16b4 <spi_ISR+0x1c>)
    16a4:	681a      	ldr	r2, [r3, #0]
    16a6:	b112      	cbz	r2, 16ae <spi_ISR+0x16>
    16a8:	681b      	ldr	r3, [r3, #0]
    16aa:	2017      	movs	r0, #23
    16ac:	4798      	blx	r3
    16ae:	e7fe      	b.n	16ae <spi_ISR+0x16>
    16b0:	00003a8e 	.word	0x00003a8e
    16b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp0_ISR:

000016b8 <ssp0_ISR>:
	while(1);
}
void ssp0_ISR (void) {
    16b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp0");
    16ba:	4905      	ldr	r1, [pc, #20]	; (16d0 <ssp0_ISR+0x18>)
    16bc:	2002      	movs	r0, #2
    16be:	f001 fa4d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(24);
    16c2:	4b04      	ldr	r3, [pc, #16]	; (16d4 <ssp0_ISR+0x1c>)
    16c4:	681a      	ldr	r2, [r3, #0]
    16c6:	b112      	cbz	r2, 16ce <ssp0_ISR+0x16>
    16c8:	681b      	ldr	r3, [r3, #0]
    16ca:	2018      	movs	r0, #24
    16cc:	4798      	blx	r3
    16ce:	e7fe      	b.n	16ce <ssp0_ISR+0x16>
    16d0:	00003a99 	.word	0x00003a99
    16d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp1_ISR:

000016d8 <ssp1_ISR>:
	while(1);
}
void ssp1_ISR (void) {
    16d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp1");
    16da:	4905      	ldr	r1, [pc, #20]	; (16f0 <ssp1_ISR+0x18>)
    16dc:	2002      	movs	r0, #2
    16de:	f001 fa3d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(25);
    16e2:	4b04      	ldr	r3, [pc, #16]	; (16f4 <ssp1_ISR+0x1c>)
    16e4:	681a      	ldr	r2, [r3, #0]
    16e6:	b112      	cbz	r2, 16ee <ssp1_ISR+0x16>
    16e8:	681b      	ldr	r3, [r3, #0]
    16ea:	2019      	movs	r0, #25
    16ec:	4798      	blx	r3
    16ee:	e7fe      	b.n	16ee <ssp1_ISR+0x16>
    16f0:	00003aa5 	.word	0x00003aa5
    16f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pll0_ISR:

000016f8 <pll0_ISR>:
	while(1);
}
void pll0_ISR (void) {
    16f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll0");
    16fa:	4905      	ldr	r1, [pc, #20]	; (1710 <pll0_ISR+0x18>)
    16fc:	2002      	movs	r0, #2
    16fe:	f001 fa2d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(26);
    1702:	4b04      	ldr	r3, [pc, #16]	; (1714 <pll0_ISR+0x1c>)
    1704:	681a      	ldr	r2, [r3, #0]
    1706:	b112      	cbz	r2, 170e <pll0_ISR+0x16>
    1708:	681b      	ldr	r3, [r3, #0]
    170a:	201a      	movs	r0, #26
    170c:	4798      	blx	r3
    170e:	e7fe      	b.n	170e <pll0_ISR+0x16>
    1710:	00003ab1 	.word	0x00003ab1
    1714:	100005fc 	.word	0x100005fc

Disassembly of section .text.rtc_ISR:

00001718 <rtc_ISR>:
	while(1);
}
void rtc_ISR (void) {
    1718:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ");
    171a:	4905      	ldr	r1, [pc, #20]	; (1730 <rtc_ISR+0x18>)
    171c:	2002      	movs	r0, #2
    171e:	f001 fa1d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(27);
    1722:	4b04      	ldr	r3, [pc, #16]	; (1734 <rtc_ISR+0x1c>)
    1724:	681a      	ldr	r2, [r3, #0]
    1726:	b112      	cbz	r2, 172e <rtc_ISR+0x16>
    1728:	681b      	ldr	r3, [r3, #0]
    172a:	201b      	movs	r0, #27
    172c:	4798      	blx	r3
    172e:	e7fe      	b.n	172e <rtc_ISR+0x16>
    1730:	00003abd 	.word	0x00003abd
    1734:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint0_ISR:

00001738 <eint0_ISR>:
	while(1);
}
void eint0_ISR (void) {
    1738:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint0");
    173a:	4905      	ldr	r1, [pc, #20]	; (1750 <eint0_ISR+0x18>)
    173c:	2002      	movs	r0, #2
    173e:	f001 fa0d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(28);
    1742:	4b04      	ldr	r3, [pc, #16]	; (1754 <eint0_ISR+0x1c>)
    1744:	681a      	ldr	r2, [r3, #0]
    1746:	b112      	cbz	r2, 174e <eint0_ISR+0x16>
    1748:	681b      	ldr	r3, [r3, #0]
    174a:	201c      	movs	r0, #28
    174c:	4798      	blx	r3
    174e:	e7fe      	b.n	174e <eint0_ISR+0x16>
    1750:	00003ac5 	.word	0x00003ac5
    1754:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint1_ISR:

00001758 <eint1_ISR>:
	while(1);
}
void eint1_ISR (void) {
    1758:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint1");
    175a:	4905      	ldr	r1, [pc, #20]	; (1770 <eint1_ISR+0x18>)
    175c:	2002      	movs	r0, #2
    175e:	f001 f9fd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(29);
    1762:	4b04      	ldr	r3, [pc, #16]	; (1774 <eint1_ISR+0x1c>)
    1764:	681a      	ldr	r2, [r3, #0]
    1766:	b112      	cbz	r2, 176e <eint1_ISR+0x16>
    1768:	681b      	ldr	r3, [r3, #0]
    176a:	201d      	movs	r0, #29
    176c:	4798      	blx	r3
    176e:	e7fe      	b.n	176e <eint1_ISR+0x16>
    1770:	00003ad2 	.word	0x00003ad2
    1774:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint2_ISR:

00001778 <eint2_ISR>:
	while(1);
}
void eint2_ISR (void) {
    1778:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint2");
    177a:	4905      	ldr	r1, [pc, #20]	; (1790 <eint2_ISR+0x18>)
    177c:	2002      	movs	r0, #2
    177e:	f001 f9ed 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(30);
    1782:	4b04      	ldr	r3, [pc, #16]	; (1794 <eint2_ISR+0x1c>)
    1784:	681a      	ldr	r2, [r3, #0]
    1786:	b112      	cbz	r2, 178e <eint2_ISR+0x16>
    1788:	681b      	ldr	r3, [r3, #0]
    178a:	201e      	movs	r0, #30
    178c:	4798      	blx	r3
    178e:	e7fe      	b.n	178e <eint2_ISR+0x16>
    1790:	00003adf 	.word	0x00003adf
    1794:	100005fc 	.word	0x100005fc

Disassembly of section .text.eint3_ISR:

00001798 <eint3_ISR>:
	while(1);
}
void eint3_ISR (void) {
    1798:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint3");
    179a:	4905      	ldr	r1, [pc, #20]	; (17b0 <eint3_ISR+0x18>)
    179c:	2002      	movs	r0, #2
    179e:	f001 f9dd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(31);
    17a2:	4b04      	ldr	r3, [pc, #16]	; (17b4 <eint3_ISR+0x1c>)
    17a4:	681a      	ldr	r2, [r3, #0]
    17a6:	b112      	cbz	r2, 17ae <eint3_ISR+0x16>
    17a8:	681b      	ldr	r3, [r3, #0]
    17aa:	201f      	movs	r0, #31
    17ac:	4798      	blx	r3
    17ae:	e7fe      	b.n	17ae <eint3_ISR+0x16>
    17b0:	00003aec 	.word	0x00003aec
    17b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.adc_ISR:

000017b8 <adc_ISR>:
	while(1);
}
void adc_ISR (void) {
    17b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr adc");
    17ba:	4905      	ldr	r1, [pc, #20]	; (17d0 <adc_ISR+0x18>)
    17bc:	2002      	movs	r0, #2
    17be:	f001 f9cd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(32);
    17c2:	4b04      	ldr	r3, [pc, #16]	; (17d4 <adc_ISR+0x1c>)
    17c4:	681a      	ldr	r2, [r3, #0]
    17c6:	b112      	cbz	r2, 17ce <adc_ISR+0x16>
    17c8:	681b      	ldr	r3, [r3, #0]
    17ca:	2020      	movs	r0, #32
    17cc:	4798      	blx	r3
    17ce:	e7fe      	b.n	17ce <adc_ISR+0x16>
    17d0:	00003af9 	.word	0x00003af9
    17d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.bod_ISR:

000017d8 <bod_ISR>:
	while(1);
}
void bod_ISR (void) {
    17d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr bod");
    17da:	4905      	ldr	r1, [pc, #20]	; (17f0 <bod_ISR+0x18>)
    17dc:	2002      	movs	r0, #2
    17de:	f001 f9bd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(33);
    17e2:	4b04      	ldr	r3, [pc, #16]	; (17f4 <bod_ISR+0x1c>)
    17e4:	681a      	ldr	r2, [r3, #0]
    17e6:	b112      	cbz	r2, 17ee <bod_ISR+0x16>
    17e8:	681b      	ldr	r3, [r3, #0]
    17ea:	2021      	movs	r0, #33	; 0x21
    17ec:	4798      	blx	r3
    17ee:	e7fe      	b.n	17ee <bod_ISR+0x16>
    17f0:	00003b04 	.word	0x00003b04
    17f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.usbHost_ISR:

000017f8 <usbHost_ISR>:
	while(1);
}
void usbHost_ISR (void) {
    17f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usb");
    17fa:	4905      	ldr	r1, [pc, #20]	; (1810 <usbHost_ISR+0x18>)
    17fc:	2002      	movs	r0, #2
    17fe:	f001 f9ad 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(34);
    1802:	4b04      	ldr	r3, [pc, #16]	; (1814 <usbHost_ISR+0x1c>)
    1804:	681a      	ldr	r2, [r3, #0]
    1806:	b112      	cbz	r2, 180e <usbHost_ISR+0x16>
    1808:	681b      	ldr	r3, [r3, #0]
    180a:	2022      	movs	r0, #34	; 0x22
    180c:	4798      	blx	r3
    180e:	e7fe      	b.n	180e <usbHost_ISR+0x16>
    1810:	00003b0f 	.word	0x00003b0f
    1814:	100005fc 	.word	0x100005fc

Disassembly of section .text.can_ISR:

00001818 <can_ISR>:
	while(1);
}
void can_ISR (void) {
    1818:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr can");
    181a:	4905      	ldr	r1, [pc, #20]	; (1830 <can_ISR+0x18>)
    181c:	2002      	movs	r0, #2
    181e:	f001 f99d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(35);
    1822:	4b04      	ldr	r3, [pc, #16]	; (1834 <can_ISR+0x1c>)
    1824:	681a      	ldr	r2, [r3, #0]
    1826:	b112      	cbz	r2, 182e <can_ISR+0x16>
    1828:	681b      	ldr	r3, [r3, #0]
    182a:	2023      	movs	r0, #35	; 0x23
    182c:	4798      	blx	r3
    182e:	e7fe      	b.n	182e <can_ISR+0x16>
    1830:	00003b1a 	.word	0x00003b1a
    1834:	100005fc 	.word	0x100005fc

Disassembly of section .text.dma_ISR:

00001838 <dma_ISR>:
	while(1);
}
void dma_ISR (void) {
    1838:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr dma");
    183a:	4905      	ldr	r1, [pc, #20]	; (1850 <dma_ISR+0x18>)
    183c:	2002      	movs	r0, #2
    183e:	f001 f98d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(36);
    1842:	4b04      	ldr	r3, [pc, #16]	; (1854 <dma_ISR+0x1c>)
    1844:	681a      	ldr	r2, [r3, #0]
    1846:	b112      	cbz	r2, 184e <dma_ISR+0x16>
    1848:	681b      	ldr	r3, [r3, #0]
    184a:	2024      	movs	r0, #36	; 0x24
    184c:	4798      	blx	r3
    184e:	e7fe      	b.n	184e <dma_ISR+0x16>
    1850:	00003b25 	.word	0x00003b25
    1854:	100005fc 	.word	0x100005fc

Disassembly of section .text.i2s_ISR:

00001858 <i2s_ISR>:
	while(1);
}
void i2s_ISR (void) {
    1858:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2s");
    185a:	4905      	ldr	r1, [pc, #20]	; (1870 <i2s_ISR+0x18>)
    185c:	2002      	movs	r0, #2
    185e:	f001 f97d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(37);
    1862:	4b04      	ldr	r3, [pc, #16]	; (1874 <i2s_ISR+0x1c>)
    1864:	681a      	ldr	r2, [r3, #0]
    1866:	b112      	cbz	r2, 186e <i2s_ISR+0x16>
    1868:	681b      	ldr	r3, [r3, #0]
    186a:	2025      	movs	r0, #37	; 0x25
    186c:	4798      	blx	r3
    186e:	e7fe      	b.n	186e <i2s_ISR+0x16>
    1870:	00003b30 	.word	0x00003b30
    1874:	100005fc 	.word	0x100005fc

Disassembly of section .text.enet_ISR:

00001878 <enet_ISR>:
	while(1);
}
void enet_ISR (void) {
    1878:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr enet");
    187a:	4905      	ldr	r1, [pc, #20]	; (1890 <enet_ISR+0x18>)
    187c:	2002      	movs	r0, #2
    187e:	f001 f96d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(38);
    1882:	4b04      	ldr	r3, [pc, #16]	; (1894 <enet_ISR+0x1c>)
    1884:	681a      	ldr	r2, [r3, #0]
    1886:	b112      	cbz	r2, 188e <enet_ISR+0x16>
    1888:	681b      	ldr	r3, [r3, #0]
    188a:	2026      	movs	r0, #38	; 0x26
    188c:	4798      	blx	r3
    188e:	e7fe      	b.n	188e <enet_ISR+0x16>
    1890:	00003b3b 	.word	0x00003b3b
    1894:	100005fc 	.word	0x100005fc

Disassembly of section .text.rit_ISR:

00001898 <rit_ISR>:
	while(1);
}
void rit_ISR (void) {
    1898:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr rit");
    189a:	4905      	ldr	r1, [pc, #20]	; (18b0 <rit_ISR+0x18>)
    189c:	2002      	movs	r0, #2
    189e:	f001 f95d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(39);
    18a2:	4b04      	ldr	r3, [pc, #16]	; (18b4 <rit_ISR+0x1c>)
    18a4:	681a      	ldr	r2, [r3, #0]
    18a6:	b112      	cbz	r2, 18ae <rit_ISR+0x16>
    18a8:	681b      	ldr	r3, [r3, #0]
    18aa:	2027      	movs	r0, #39	; 0x27
    18ac:	4798      	blx	r3
    18ae:	e7fe      	b.n	18ae <rit_ISR+0x16>
    18b0:	00003b47 	.word	0x00003b47
    18b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.mcpwm_ISR:

000018b8 <mcpwm_ISR>:
	while(1);
}
void mcpwm_ISR (void) {
    18b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr mcpwm");
    18ba:	4905      	ldr	r1, [pc, #20]	; (18d0 <mcpwm_ISR+0x18>)
    18bc:	2002      	movs	r0, #2
    18be:	f001 f94d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(40);
    18c2:	4b04      	ldr	r3, [pc, #16]	; (18d4 <mcpwm_ISR+0x1c>)
    18c4:	681a      	ldr	r2, [r3, #0]
    18c6:	b112      	cbz	r2, 18ce <mcpwm_ISR+0x16>
    18c8:	681b      	ldr	r3, [r3, #0]
    18ca:	2028      	movs	r0, #40	; 0x28
    18cc:	4798      	blx	r3
    18ce:	e7fe      	b.n	18ce <mcpwm_ISR+0x16>
    18d0:	00003b52 	.word	0x00003b52
    18d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.qei_ISR:

000018d8 <qei_ISR>:
	while(1);
}
void qei_ISR (void) {
    18d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr qei");
    18da:	4905      	ldr	r1, [pc, #20]	; (18f0 <qei_ISR+0x18>)
    18dc:	2002      	movs	r0, #2
    18de:	f001 f93d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(41);
    18e2:	4b04      	ldr	r3, [pc, #16]	; (18f4 <qei_ISR+0x1c>)
    18e4:	681a      	ldr	r2, [r3, #0]
    18e6:	b112      	cbz	r2, 18ee <qei_ISR+0x16>
    18e8:	681b      	ldr	r3, [r3, #0]
    18ea:	2029      	movs	r0, #41	; 0x29
    18ec:	4798      	blx	r3
    18ee:	e7fe      	b.n	18ee <qei_ISR+0x16>
    18f0:	00003b5f 	.word	0x00003b5f
    18f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pll1_ISR:

000018f8 <pll1_ISR>:
	while(1);
}

void pll1_ISR (void) {
    18f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll1");
    18fa:	4905      	ldr	r1, [pc, #20]	; (1910 <pll1_ISR+0x18>)
    18fc:	2002      	movs	r0, #2
    18fe:	f001 f92d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(42);
    1902:	4b04      	ldr	r3, [pc, #16]	; (1914 <pll1_ISR+0x1c>)
    1904:	681a      	ldr	r2, [r3, #0]
    1906:	b112      	cbz	r2, 190e <pll1_ISR+0x16>
    1908:	681b      	ldr	r3, [r3, #0]
    190a:	202a      	movs	r0, #42	; 0x2a
    190c:	4798      	blx	r3
    190e:	e7fe      	b.n	190e <pll1_ISR+0x16>
    1910:	00003b6a 	.word	0x00003b6a
    1914:	100005fc 	.word	0x100005fc

Disassembly of section .text.usbAct_ISR:

00001918 <usbAct_ISR>:
	while(1);
}

void usbAct_ISR (void) {
    1918:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr USB ACT");
    191a:	4905      	ldr	r1, [pc, #20]	; (1930 <usbAct_ISR+0x18>)
    191c:	2002      	movs	r0, #2
    191e:	f001 f91d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(43);
    1922:	4b04      	ldr	r3, [pc, #16]	; (1934 <usbAct_ISR+0x1c>)
    1924:	681a      	ldr	r2, [r3, #0]
    1926:	b112      	cbz	r2, 192e <usbAct_ISR+0x16>
    1928:	681b      	ldr	r3, [r3, #0]
    192a:	202b      	movs	r0, #43	; 0x2b
    192c:	4798      	blx	r3
    192e:	e7fe      	b.n	192e <usbAct_ISR+0x16>
    1930:	00003b76 	.word	0x00003b76
    1934:	100005fc 	.word	0x100005fc

Disassembly of section .text.canAct_ISR:

00001938 <canAct_ISR>:
	while(1);
}
void canAct_ISR (void) {
    1938:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr CAN ACT");
    193a:	4905      	ldr	r1, [pc, #20]	; (1950 <canAct_ISR+0x18>)
    193c:	2002      	movs	r0, #2
    193e:	f001 f90d 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(44);
    1942:	4b04      	ldr	r3, [pc, #16]	; (1954 <canAct_ISR+0x1c>)
    1944:	681a      	ldr	r2, [r3, #0]
    1946:	b112      	cbz	r2, 194e <canAct_ISR+0x16>
    1948:	681b      	ldr	r3, [r3, #0]
    194a:	202c      	movs	r0, #44	; 0x2c
    194c:	4798      	blx	r3
    194e:	e7fe      	b.n	194e <canAct_ISR+0x16>
    1950:	00003b85 	.word	0x00003b85
    1954:	100005fc 	.word	0x100005fc

Disassembly of section .text.uart4_ISR:

00001958 <uart4_ISR>:
	while(1);
}
void uart4_ISR (void) {
    1958:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart4");
    195a:	4905      	ldr	r1, [pc, #20]	; (1970 <uart4_ISR+0x18>)
    195c:	2002      	movs	r0, #2
    195e:	f001 f8fd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(45);
    1962:	4b04      	ldr	r3, [pc, #16]	; (1974 <uart4_ISR+0x1c>)
    1964:	681a      	ldr	r2, [r3, #0]
    1966:	b112      	cbz	r2, 196e <uart4_ISR+0x16>
    1968:	681b      	ldr	r3, [r3, #0]
    196a:	202d      	movs	r0, #45	; 0x2d
    196c:	4798      	blx	r3
    196e:	e7fe      	b.n	196e <uart4_ISR+0x16>
    1970:	00003b94 	.word	0x00003b94
    1974:	100005fc 	.word	0x100005fc

Disassembly of section .text.ssp2_ISR:

00001978 <ssp2_ISR>:
	while(1);
}
void ssp2_ISR (void) {
    1978:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ssp2");
    197a:	4905      	ldr	r1, [pc, #20]	; (1990 <ssp2_ISR+0x18>)
    197c:	2002      	movs	r0, #2
    197e:	f001 f8ed 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(46);
    1982:	4b04      	ldr	r3, [pc, #16]	; (1994 <ssp2_ISR+0x1c>)
    1984:	681a      	ldr	r2, [r3, #0]
    1986:	b112      	cbz	r2, 198e <ssp2_ISR+0x16>
    1988:	681b      	ldr	r3, [r3, #0]
    198a:	202e      	movs	r0, #46	; 0x2e
    198c:	4798      	blx	r3
    198e:	e7fe      	b.n	198e <ssp2_ISR+0x16>
    1990:	00003ba1 	.word	0x00003ba1
    1994:	100005fc 	.word	0x100005fc

Disassembly of section .text.lcd_ISR:

00001998 <lcd_ISR>:
	while(1);
}
void lcd_ISR (void) {
    1998:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr lcd");
    199a:	4905      	ldr	r1, [pc, #20]	; (19b0 <lcd_ISR+0x18>)
    199c:	2002      	movs	r0, #2
    199e:	f001 f8dd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(47);
    19a2:	4b04      	ldr	r3, [pc, #16]	; (19b4 <lcd_ISR+0x1c>)
    19a4:	681a      	ldr	r2, [r3, #0]
    19a6:	b112      	cbz	r2, 19ae <lcd_ISR+0x16>
    19a8:	681b      	ldr	r3, [r3, #0]
    19aa:	202f      	movs	r0, #47	; 0x2f
    19ac:	4798      	blx	r3
    19ae:	e7fe      	b.n	19ae <lcd_ISR+0x16>
    19b0:	00003bad 	.word	0x00003bad
    19b4:	100005fc 	.word	0x100005fc

Disassembly of section .text.gpio_ISR:

000019b8 <gpio_ISR>:
	while(1);
}
void gpio_ISR (void) {
    19b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr gpio");
    19ba:	4905      	ldr	r1, [pc, #20]	; (19d0 <gpio_ISR+0x18>)
    19bc:	2002      	movs	r0, #2
    19be:	f001 f8cd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(48);
    19c2:	4b04      	ldr	r3, [pc, #16]	; (19d4 <gpio_ISR+0x1c>)
    19c4:	681a      	ldr	r2, [r3, #0]
    19c6:	b112      	cbz	r2, 19ce <gpio_ISR+0x16>
    19c8:	681b      	ldr	r3, [r3, #0]
    19ca:	2030      	movs	r0, #48	; 0x30
    19cc:	4798      	blx	r3
    19ce:	e7fe      	b.n	19ce <gpio_ISR+0x16>
    19d0:	00003bb8 	.word	0x00003bb8
    19d4:	100005fc 	.word	0x100005fc

Disassembly of section .text.pwm0_ISR:

000019d8 <pwm0_ISR>:
	while(1);
}
void pwm0_ISR (void) {
    19d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm0");
    19da:	4905      	ldr	r1, [pc, #20]	; (19f0 <pwm0_ISR+0x18>)
    19dc:	2002      	movs	r0, #2
    19de:	f001 f8bd 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(49);
    19e2:	4b04      	ldr	r3, [pc, #16]	; (19f4 <pwm0_ISR+0x1c>)
    19e4:	681a      	ldr	r2, [r3, #0]
    19e6:	b112      	cbz	r2, 19ee <pwm0_ISR+0x16>
    19e8:	681b      	ldr	r3, [r3, #0]
    19ea:	2031      	movs	r0, #49	; 0x31
    19ec:	4798      	blx	r3
    19ee:	e7fe      	b.n	19ee <pwm0_ISR+0x16>
    19f0:	00003bc4 	.word	0x00003bc4
    19f4:	100005fc 	.word	0x100005fc

Disassembly of section .text.eeprom_ISR:

000019f8 <eeprom_ISR>:
	while(1);
}
void eeprom_ISR (void) {
    19f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eeprom");
    19fa:	4905      	ldr	r1, [pc, #20]	; (1a10 <eeprom_ISR+0x18>)
    19fc:	2002      	movs	r0, #2
    19fe:	f001 f8ad 	bl	2b5c <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(50);
    1a02:	4b04      	ldr	r3, [pc, #16]	; (1a14 <eeprom_ISR+0x1c>)
    1a04:	681a      	ldr	r2, [r3, #0]
    1a06:	b112      	cbz	r2, 1a0e <eeprom_ISR+0x16>
    1a08:	681b      	ldr	r3, [r3, #0]
    1a0a:	2032      	movs	r0, #50	; 0x32
    1a0c:	4798      	blx	r3
    1a0e:	e7fe      	b.n	1a0e <eeprom_ISR+0x16>
    1a10:	00003bd0 	.word	0x00003bd0
    1a14:	100005fc 	.word	0x100005fc

Disassembly of section .text.nvic_setPendingIRQ:

00001a18 <nvic_setPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a18:	0943      	lsrs	r3, r0, #5
    1a1a:	009b      	lsls	r3, r3, #2
    1a1c:	f103 4360 	add.w	r3, r3, #3758096384	; 0xe0000000
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    1a20:	f000 001f 	and.w	r0, r0, #31
    1a24:	2201      	movs	r2, #1
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a26:	f503 4361 	add.w	r3, r3, #57600	; 0xe100
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    1a2a:	fa02 f000 	lsl.w	r0, r2, r0
    1a2e:	6018      	str	r0, [r3, #0]
    1a30:	4770      	bx	lr

Disassembly of section .text.nvic_enableIRQ:

00001a32 <nvic_enableIRQ>:
    1a32:	f7ff bff1 	b.w	1a18 <nvic_setPendingIRQ>

Disassembly of section .text.nvic_clearPendingIRQ:

00001a38 <nvic_clearPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_clearPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ICPR0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    1a38:	0942      	lsrs	r2, r0, #5
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Desabilitar a pendencia interrupção do periférico
    1a3a:	2301      	movs	r3, #1
    1a3c:	f000 001f 	and.w	r0, r0, #31
    1a40:	fa03 f000 	lsl.w	r0, r3, r0
    1a44:	4b01      	ldr	r3, [pc, #4]	; (1a4c <nvic_clearPendingIRQ+0x14>)
    1a46:	f843 0022 	str.w	r0, [r3, r2, lsl #2]
    1a4a:	4770      	bx	lr
    1a4c:	e000e280 	.word	0xe000e280

Disassembly of section .text.nvic_setPriority:

00001a50 <nvic_setPriority>:
// -----------------------------------------------------------------------------------------------
void nvic_setPriority(s32 numIRQ, u8 priority) {
	#if (VIC_USE_DEBUG == pdON)
	plognp("set pri %d %u"CMD_TERMINATOR, numIRQ, priority);
	#endif
	if(numIRQ < 0) {
    1a50:	2800      	cmp	r0, #0
    1a52:	b2c3      	uxtb	r3, r0
    1a54:	ea4f 01c1 	mov.w	r1, r1, lsl #3
    1a58:	da0d      	bge.n	1a76 <nvic_setPriority+0x26>
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a5a:	f000 000f 	and.w	r0, r0, #15
    1a5e:	2204      	movs	r2, #4
    1a60:	3804      	subs	r0, #4
    1a62:	fb90 f0f2 	sdiv	r0, r0, r2
    1a66:	f003 0303 	and.w	r3, r3, #3
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a6a:	4a09      	ldr	r2, [pc, #36]	; (1a90 <nvic_setPriority+0x40>)
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a6c:	eb03 0380 	add.w	r3, r3, r0, lsl #2
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a70:	b2c9      	uxtb	r1, r1
    1a72:	5499      	strb	r1, [r3, r2]
    1a74:	4770      	bx	lr
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset init 0x%x"CMD_TERMINATOR, offset);
		#endif
		offset+=(reg8)numIRQ%4;
    1a76:	f020 0003 	bic.w	r0, r0, #3
    1a7a:	f003 0303 	and.w	r3, r3, #3
    1a7e:	4418      	add	r0, r3
    1a80:	f100 4060 	add.w	r0, r0, #3758096384	; 0xe0000000
    1a84:	f500 4064 	add.w	r0, r0, #58368	; 0xe400
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset 0x%x = 0x%x"CMD_TERMINATOR, offset, ((priority << (8 - VIC_PRIO_BITS)) & 0xff));
		#endif
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a88:	b2c9      	uxtb	r1, r1
    1a8a:	7001      	strb	r1, [r0, #0]
    1a8c:	4770      	bx	lr
    1a8e:	bf00      	nop
    1a90:	e000ed18 	.word	0xe000ed18

Disassembly of section .text.nvic_SetIntHandler:

00001a94 <nvic_SetIntHandler>:
//						}
//						ATENÇÃO: NUNCA USA O DELAY COM INTERRUPÇÃO, USE A LIB COM LOOP, pois se este é um procedimento de erro de
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void nvic_SetIntHandler(void (*func)(int) ) {
	vicerr_Functions = func;
    1a94:	4b01      	ldr	r3, [pc, #4]	; (1a9c <nvic_SetIntHandler+0x8>)
    1a96:	6018      	str	r0, [r3, #0]
    1a98:	4770      	bx	lr
    1a9a:	bf00      	nop
    1a9c:	100005fc 	.word	0x100005fc

Disassembly of section .text.systime_Init:

00001aa0 <systime_Init>:
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1aa0:	4a10      	ldr	r2, [pc, #64]	; (1ae4 <systime_Init+0x44>)

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema

	return pdPASS;
}
    1aa2:	2001      	movs	r0, #1
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1aa4:	6813      	ldr	r3, [r2, #0]
    1aa6:	f043 5380 	orr.w	r3, r3, #268435456	; 0x10000000
    1aaa:	6013      	str	r3, [r2, #0]
	countTicksLed = 0;
    1aac:	4b0e      	ldr	r3, [pc, #56]	; (1ae8 <systime_Init+0x48>)
    1aae:	2200      	movs	r2, #0
    1ab0:	601a      	str	r2, [r3, #0]
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1ab2:	4b0e      	ldr	r3, [pc, #56]	; (1aec <systime_Init+0x4c>)
    1ab4:	6819      	ldr	r1, [r3, #0]
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1ab6:	f6a3 530c 	subw	r3, r3, #3340	; 0xd0c
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
	countTicksLed = 0;
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1aba:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
    1abe:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );
    1ac2:	f8d3 1d0c 	ldr.w	r1, [r3, #3340]	; 0xd0c
    1ac6:	f041 4178 	orr.w	r1, r1, #4160749568	; 0xf8000000
    1aca:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1ace:	4908      	ldr	r1, [pc, #32]	; (1af0 <systime_Init+0x50>)
    1ad0:	6019      	str	r1, [r3, #0]
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );
    1ad2:	2107      	movs	r1, #7
    1ad4:	f843 1c04 	str.w	r1, [r3, #-4]
// Descrição: 	Retira a routina da inetrrupçao desejada do vetor de interrupções
// Parametros:	Nenhum
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_ClearIntHandler(void) {
	systime_IntFunctions = 0;
    1ad8:	4b06      	ldr	r3, [pc, #24]	; (1af4 <systime_Init+0x54>)
    1ada:	601a      	str	r2, [r3, #0]
	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema
    1adc:	4b06      	ldr	r3, [pc, #24]	; (1af8 <systime_Init+0x58>)
    1ade:	601a      	str	r2, [r3, #0]

	return pdPASS;
}
    1ae0:	4770      	bx	lr
    1ae2:	bf00      	nop
    1ae4:	2009c080 	.word	0x2009c080
    1ae8:	10000600 	.word	0x10000600
    1aec:	e000ed20 	.word	0xe000ed20
    1af0:	0001869f 	.word	0x0001869f
    1af4:	1000060c 	.word	0x1000060c
    1af8:	10000604 	.word	0x10000604

Disassembly of section .text.systime_SetIntHandler:

00001afc <systime_SetIntHandler>:
//					Ponteiro da rotina que tratará a interrupção do timer.
//					Ex:	systime_SetIntHandler(myOverflowFunction, xticks);
//				xticks: Quantidade de ticks que a função deve ser chamada. Consultar SYSTIME_BASE_TICK
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_SetIntHandler(void (*int_func)(void), uint xticks ) {
    1afc:	4b02      	ldr	r3, [pc, #8]	; (1b08 <systime_SetIntHandler+0xc>)
	if (xticks == 0) { systime_IntFunctions = 0; return;}
    1afe:	b109      	cbz	r1, 1b04 <systime_SetIntHandler+0x8>
	systime_IntFunctions = int_func;
    1b00:	6018      	str	r0, [r3, #0]
	callfuncTime = xticks;
    1b02:	4b02      	ldr	r3, [pc, #8]	; (1b0c <systime_SetIntHandler+0x10>)
    1b04:	6019      	str	r1, [r3, #0]
    1b06:	4770      	bx	lr
    1b08:	1000060c 	.word	0x1000060c
    1b0c:	10000608 	.word	0x10000608

Disassembly of section .text.sysTick_ISR:

00001b10 <sysTick_ISR>:

// ################################################################################################################
// SYSTEM TIMER INTERRUPÇÃO
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    1b10:	b508      	push	{r3, lr}
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1b12:	4b12      	ldr	r3, [pc, #72]	; (1b5c <sysTick_ISR+0x4c>)

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1b14:	4912      	ldr	r1, [pc, #72]	; (1b60 <sysTick_ISR+0x50>)
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1b16:	681a      	ldr	r2, [r3, #0]
    1b18:	3201      	adds	r2, #1
    1b1a:	601a      	str	r2, [r3, #0]

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1b1c:	680a      	ldr	r2, [r1, #0]
    1b1e:	b14a      	cbz	r2, 1b34 <sysTick_ISR+0x24>
    1b20:	6818      	ldr	r0, [r3, #0]
    1b22:	4b10      	ldr	r3, [pc, #64]	; (1b64 <sysTick_ISR+0x54>)
    1b24:	681b      	ldr	r3, [r3, #0]
    1b26:	fbb0 f2f3 	udiv	r2, r0, r3
    1b2a:	fb03 0312 	mls	r3, r3, r2, r0
    1b2e:	b90b      	cbnz	r3, 1b34 <sysTick_ISR+0x24>
		systime_IntFunctions();					// Execute a função anexada
    1b30:	680b      	ldr	r3, [r1, #0]
    1b32:	4798      	blx	r3

	#if (SYSTIME_USE_LED == pdON)
	if (countTicksLed >= SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK + SYSTIME_LED_ON_MS*SYSTIME_BASE_TICK)
    1b34:	4b0c      	ldr	r3, [pc, #48]	; (1b68 <sysTick_ISR+0x58>)
    1b36:	681a      	ldr	r2, [r3, #0]
    1b38:	f5b2 7f7a 	cmp.w	r2, #1000	; 0x3e8
		countTicksLed = 0;
    1b3c:	bf24      	itt	cs
    1b3e:	2200      	movcs	r2, #0
    1b40:	601a      	strcs	r2, [r3, #0]
		countTicksLed++;
    1b42:	681a      	ldr	r2, [r3, #0]
    1b44:	3201      	adds	r2, #1
    1b46:	601a      	str	r2, [r3, #0]
		if (countTicksLed > SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK) {
    1b48:	681b      	ldr	r3, [r3, #0]
    1b4a:	f5b3 7f61 	cmp.w	r3, #900	; 0x384
			ledSYSTIME_ON = ledSYSTIME;
    1b4e:	bf8c      	ite	hi
    1b50:	4a06      	ldrhi	r2, [pc, #24]	; (1b6c <sysTick_ISR+0x5c>)
		} else {
			ledSYSTIME_OFF = ledSYSTIME;
    1b52:	4a07      	ldrls	r2, [pc, #28]	; (1b70 <sysTick_ISR+0x60>)
    1b54:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
    1b58:	6013      	str	r3, [r2, #0]
    1b5a:	bd08      	pop	{r3, pc}
    1b5c:	10000604 	.word	0x10000604
    1b60:	1000060c 	.word	0x1000060c
    1b64:	10000608 	.word	0x10000608
    1b68:	10000600 	.word	0x10000600
    1b6c:	2009c098 	.word	0x2009c098
    1b70:	2009c09c 	.word	0x2009c09c

Disassembly of section .text.delay:

00001b74 <delay>:
*/

#include "delay.h"

void delay(u32 delayval) {
	asm volatile (
    1b74:	3801      	subs	r0, #1
    1b76:	d1fd      	bne.n	1b74 <delay>
    1b78:	4770      	bx	lr

Disassembly of section .text.uart0_SetBaudrate:

00001b80 <uart0_SetBaudrate>:
		}
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
    1b80:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    1b84:	4680      	mov	r8, r0
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b86:	4e34      	ldr	r6, [pc, #208]	; (1c58 <uart0_SetBaudrate+0xd8>)
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b88:	4834      	ldr	r0, [pc, #208]	; (1c5c <uart0_SetBaudrate+0xdc>)
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b8a:	2380      	movs	r3, #128	; 0x80
    1b8c:	6033      	str	r3, [r6, #0]
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b8e:	fb90 f0f8 	sdiv	r0, r0, r8
    1b92:	f7fe fd05 	bl	5a0 <__aeabi_i2d>
    1b96:	a32c      	add	r3, pc, #176	; (adr r3, 1c48 <uart0_SetBaudrate+0xc8>)
    1b98:	e9d3 2300 	ldrd	r2, r3, [r3]
    1b9c:	f7fe fd66 	bl	66c <__aeabi_dmul>
    1ba0:	f7fe fffe 	bl	ba0 <__aeabi_d2iz>
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
    1ba4:	46c2      	mov	sl, r8
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1ba6:	4607      	mov	r7, r0

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
    1ba8:	4b2d      	ldr	r3, [pc, #180]	; (1c60 <uart0_SetBaudrate+0xe0>)
    1baa:	b2c2      	uxtb	r2, r0
    1bac:	601a      	str	r2, [r3, #0]
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
    1bae:	0a02      	lsrs	r2, r0, #8
    1bb0:	605a      	str	r2, [r3, #4]
//	fraction = BAUD*(1+D/M)
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
    1bb2:	f04f 0910 	mov.w	r9, #16
	e = baud;
	for(m=1;m<=15;m++) {
    1bb6:	2401      	movs	r4, #1
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
				e = abs(baud-b);
				r = (m<<4) + d;
    1bb8:	ea4f 1b04 	mov.w	fp, r4, lsl #4
    1bbc:	2500      	movs	r5, #0
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1bbe:	4628      	mov	r0, r5
    1bc0:	f7ff f8d0 	bl	d64 <__aeabi_i2f>
    1bc4:	9001      	str	r0, [sp, #4]
    1bc6:	4620      	mov	r0, r4
    1bc8:	f7ff f8cc 	bl	d64 <__aeabi_i2f>
    1bcc:	9b01      	ldr	r3, [sp, #4]
    1bce:	4601      	mov	r1, r0
    1bd0:	4618      	mov	r0, r3
    1bd2:	f7ff f9cf 	bl	f74 <__aeabi_fdiv>
    1bd6:	f04f 517e 	mov.w	r1, #1065353216	; 0x3f800000
    1bda:	f7ff f80f 	bl	bfc <__addsf3>
    1bde:	9001      	str	r0, [sp, #4]
    1be0:	4638      	mov	r0, r7
    1be2:	f7ff f8bf 	bl	d64 <__aeabi_i2f>
    1be6:	9b01      	ldr	r3, [sp, #4]
    1be8:	4601      	mov	r1, r0
    1bea:	4618      	mov	r0, r3
    1bec:	f7ff f90e 	bl	e0c <__aeabi_fmul>
    1bf0:	f7fe fce8 	bl	5c4 <__aeabi_f2d>
    1bf4:	2200      	movs	r2, #0
    1bf6:	4b1b      	ldr	r3, [pc, #108]	; (1c64 <uart0_SetBaudrate+0xe4>)
    1bf8:	f7fe fd38 	bl	66c <__aeabi_dmul>
    1bfc:	4602      	mov	r2, r0
    1bfe:	460b      	mov	r3, r1
    1c00:	a113      	add	r1, pc, #76	; (adr r1, 1c50 <uart0_SetBaudrate+0xd0>)
    1c02:	e9d1 0100 	ldrd	r0, r1, [r1]
    1c06:	f7fe fe5b 	bl	8c0 <__aeabi_ddiv>
    1c0a:	f7fe ffc9 	bl	ba0 <__aeabi_d2iz>
    1c0e:	ebc0 0008 	rsb	r0, r0, r8
    1c12:	2800      	cmp	r0, #0
    1c14:	bfb8      	it	lt
    1c16:	4240      	neglt	r0, r0
    1c18:	4550      	cmp	r0, sl
    1c1a:	bfb8      	it	lt
    1c1c:	eb05 090b 	addlt.w	r9, r5, fp
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1c20:	f105 0501 	add.w	r5, r5, #1
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1c24:	bfb8      	it	lt
    1c26:	4682      	movlt	sl, r0
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1c28:	42ac      	cmp	r4, r5
    1c2a:	d1c8      	bne.n	1bbe <uart0_SetBaudrate+0x3e>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
    1c2c:	3401      	adds	r4, #1
    1c2e:	2c10      	cmp	r4, #16
    1c30:	d1c2      	bne.n	1bb8 <uart0_SetBaudrate+0x38>
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
  	U0FDR = uart_fdr(baudrate);
    1c32:	4b0d      	ldr	r3, [pc, #52]	; (1c68 <uart0_SetBaudrate+0xe8>)
    1c34:	f8c3 9000 	str.w	r9, [r3]
	U0LCR = (UART0_MODE & ~U0LCR_DLAB_ENABLE);					// Configura o modo de trabalho da uart e desativa o acesso aos registradores do baudrate
    1c38:	2303      	movs	r3, #3
    1c3a:	6033      	str	r3, [r6, #0]
}
    1c3c:	b003      	add	sp, #12
    1c3e:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    1c42:	bf00      	nop
    1c44:	f3af 8000 	nop.w
    1c48:	9999999a 	.word	0x9999999a
    1c4c:	3fe99999 	.word	0x3fe99999
    1c50:	00000000 	.word	0x00000000
    1c54:	4177d784 	.word	0x4177d784
    1c58:	4000c00c 	.word	0x4000c00c
    1c5c:	0017d784 	.word	0x0017d784
    1c60:	4000c000 	.word	0x4000c000
    1c64:	40300000 	.word	0x40300000
    1c68:	4000c028 	.word	0x4000c028

Disassembly of section .text.uart0_Init:

00001c6c <uart0_Init>:
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c6c:	4a1f      	ldr	r2, [pc, #124]	; (1cec <uart0_Init+0x80>)
// Descrição: 	Incializa e configura o modo de trabalho da UART
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
    1c6e:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c72:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c74:	4c1e      	ldr	r4, [pc, #120]	; (1cf0 <uart0_Init+0x84>)
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c76:	f043 0308 	orr.w	r3, r3, #8
    1c7a:	6013      	str	r3, [r2, #0]
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c7c:	4a1d      	ldr	r2, [pc, #116]	; (1cf4 <uart0_Init+0x88>)
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c7e:	4d1e      	ldr	r5, [pc, #120]	; (1cf8 <uart0_Init+0x8c>)
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c80:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c82:	2600      	movs	r6, #0
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c84:	f043 0350 	orr.w	r3, r3, #80	; 0x50
    1c88:	6013      	str	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c8a:	6026      	str	r6, [r4, #0]
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c8c:	682b      	ldr	r3, [r5, #0]
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    1c8e:	2306      	movs	r3, #6
    1c90:	602b      	str	r3, [r5, #0]
  	
  	uart0_SetBaudrate(baudrate);
    1c92:	f7ff ff75 	bl	1b80 <uart0_SetBaudrate>

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c96:	2701      	movs	r7, #1
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c98:	4b18      	ldr	r3, [pc, #96]	; (1cfc <uart0_Init+0x90>)
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
  	
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c9a:	602f      	str	r7, [r5, #0]
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c9c:	681b      	ldr	r3, [r3, #0]
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1c9e:	4b18      	ldr	r3, [pc, #96]	; (1d00 <uart0_Init+0x94>)
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1ca0:	f04f 0802 	mov.w	r8, #2
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1ca4:	681b      	ldr	r3, [r3, #0]
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U0FCR = U0FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1ca6:	2304      	movs	r3, #4

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1ca8:	f8c5 8000 	str.w	r8, [r5]
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1cac:	2005      	movs	r0, #5
  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U0FCR = U0FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1cae:	602b      	str	r3, [r5, #0]
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1cb0:	f7ff febf 	bl	1a32 <nvic_enableIRQ>
	nvic_setPriority(VIC_UART0, UART0_PRIO_LEVEL);
    1cb4:	4641      	mov	r1, r8
    1cb6:	2005      	movs	r0, #5
    1cb8:	f7ff feca 	bl	1a50 <nvic_setPriority>
	#if (USE_MALLOC == pdON)
	u0_data_rx = malloc(UART0_RX_BUFFER_SIZE*sizeof(u8));
	u0_data_tx = malloc(UART0_TX_BUFFER_SIZE*sizeof(u8));
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
    1cbc:	2296      	movs	r2, #150	; 0x96
    1cbe:	4911      	ldr	r1, [pc, #68]	; (1d04 <uart0_Init+0x98>)
    1cc0:	4811      	ldr	r0, [pc, #68]	; (1d08 <uart0_Init+0x9c>)
    1cc2:	f000 ff60 	bl	2b86 <buffer_Init>
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
    1cc6:	2296      	movs	r2, #150	; 0x96
    1cc8:	4910      	ldr	r1, [pc, #64]	; (1d0c <uart0_Init+0xa0>)
    1cca:	4811      	ldr	r0, [pc, #68]	; (1d10 <uart0_Init+0xa4>)
    1ccc:	f000 ff5b 	bl	2b86 <buffer_Init>
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1cd0:	4b10      	ldr	r3, [pc, #64]	; (1d14 <uart0_Init+0xa8>)
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão

	return pdPASS;
}
    1cd2:	4638      	mov	r0, r7
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1cd4:	801e      	strh	r6, [r3, #0]
	u0_tx_running = pdFALSE;
    1cd6:	4b10      	ldr	r3, [pc, #64]	; (1d18 <uart0_Init+0xac>)
    1cd8:	701e      	strb	r6, [r3, #0]
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1cda:	6823      	ldr	r3, [r4, #0]
    1cdc:	433b      	orrs	r3, r7
    1cde:	6023      	str	r3, [r4, #0]
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão
    1ce0:	6823      	ldr	r3, [r4, #0]
    1ce2:	f023 0302 	bic.w	r3, r3, #2
    1ce6:	6023      	str	r3, [r4, #0]

	return pdPASS;
}
    1ce8:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    1cec:	400fc0c4 	.word	0x400fc0c4
    1cf0:	4000c004 	.word	0x4000c004
    1cf4:	4002c000 	.word	0x4002c000
    1cf8:	4000c008 	.word	0x4000c008
    1cfc:	4000c000 	.word	0x4000c000
    1d00:	4000c014 	.word	0x4000c014
    1d04:	100006c4 	.word	0x100006c4
    1d08:	100006ac 	.word	0x100006ac
    1d0c:	10000610 	.word	0x10000610
    1d10:	100006b8 	.word	0x100006b8
    1d14:	100006a8 	.word	0x100006a8
    1d18:	100006a6 	.word	0x100006a6

Disassembly of section .text.uart0_GetChar:

00001d1c <uart0_GetChar>:
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Captura o próximo byte recebido na UART
// Parametros: 	Ponteiro para da variavel char para o retorno do byte recebido
// Retorna:		pdPASS indicando que existe caractere recebido ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
    1d1c:	b538      	push	{r3, r4, r5, lr}
    1d1e:	4605      	mov	r5, r0
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
    1d20:	480d      	ldr	r0, [pc, #52]	; (1d58 <uart0_GetChar+0x3c>)
    1d22:	8883      	ldrh	r3, [r0, #4]
    1d24:	b29b      	uxth	r3, r3
    1d26:	b18b      	cbz	r3, 1d4c <uart0_GetChar+0x30>
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
    1d28:	88c3      	ldrh	r3, [r0, #6]
    1d2a:	b29b      	uxth	r3, r3
    1d2c:	b18b      	cbz	r3, 1d52 <uart0_GetChar+0x36>
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d2e:	4c0b      	ldr	r4, [pc, #44]	; (1d5c <uart0_GetChar+0x40>)
    1d30:	6823      	ldr	r3, [r4, #0]
    1d32:	f023 0301 	bic.w	r3, r3, #1
    1d36:	6023      	str	r3, [r4, #0]
		nop();
    1d38:	bf00      	nop
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
    1d3a:	f000 ff2a 	bl	2b92 <buffer_GetFromFront>
    1d3e:	7028      	strb	r0, [r5, #0]
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d40:	6823      	ldr	r3, [r4, #0]
		ret = pdPASS;
    1d42:	2001      	movs	r0, #1

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d44:	f043 0301 	orr.w	r3, r3, #1
    1d48:	6023      	str	r3, [r4, #0]
    1d4a:	bd38      	pop	{r3, r4, r5, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro
    1d4c:	f06f 000b 	mvn.w	r0, #11
    1d50:	bd38      	pop	{r3, r4, r5, pc}
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		ret = pdPASS;
	} else
		ret = errBUFFER_EMPTY;
    1d52:	f06f 000a 	mvn.w	r0, #10

	return ret;
}
    1d56:	bd38      	pop	{r3, r4, r5, pc}
    1d58:	100006ac 	.word	0x100006ac
    1d5c:	4000c004 	.word	0x4000c004

Disassembly of section .text.uart0_PutChar:

00001d60 <uart0_PutChar>:
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d60:	4b15      	ldr	r3, [pc, #84]	; (1db8 <uart0_PutChar+0x58>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Coloca um caractere na fila de transmissão
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
    1d62:	b570      	push	{r4, r5, r6, lr}
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d64:	889b      	ldrh	r3, [r3, #4]
    1d66:	b29b      	uxth	r3, r3
    1d68:	b303      	cbz	r3, 1dac <uart0_PutChar+0x4c>
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d6a:	4c14      	ldr	r4, [pc, #80]	; (1dbc <uart0_PutChar+0x5c>)
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d6c:	b2c5      	uxtb	r5, r0
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d6e:	6823      	ldr	r3, [r4, #0]
    1d70:	4e12      	ldr	r6, [pc, #72]	; (1dbc <uart0_PutChar+0x5c>)
    1d72:	f023 0302 	bic.w	r3, r3, #2
    1d76:	6023      	str	r3, [r4, #0]
		nop();
    1d78:	bf00      	nop
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d7a:	480f      	ldr	r0, [pc, #60]	; (1db8 <uart0_PutChar+0x58>)
    1d7c:	4629      	mov	r1, r5
    1d7e:	f000 ff2a 	bl	2bd6 <buffer_AddToEnd>
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d82:	6823      	ldr	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d84:	300a      	adds	r0, #10

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d86:	f043 0302 	orr.w	r3, r3, #2
    1d8a:	6023      	str	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d8c:	d0ef      	beq.n	1d6e <uart0_PutChar+0xe>

	if (!u0_tx_running) {													// Checa se existe dado sendo transmitido
    1d8e:	4c0c      	ldr	r4, [pc, #48]	; (1dc0 <uart0_PutChar+0x60>)
    1d90:	7823      	ldrb	r3, [r4, #0]
    1d92:	b973      	cbnz	r3, 1db2 <uart0_PutChar+0x52>
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
    1d94:	4808      	ldr	r0, [pc, #32]	; (1db8 <uart0_PutChar+0x58>)
    1d96:	f000 fefc 	bl	2b92 <buffer_GetFromFront>
    1d9a:	4b0a      	ldr	r3, [pc, #40]	; (1dc4 <uart0_PutChar+0x64>)
    1d9c:	6018      	str	r0, [r3, #0]
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
    1d9e:	2001      	movs	r0, #1
    1da0:	7020      	strb	r0, [r4, #0]
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1da2:	6833      	ldr	r3, [r6, #0]
    1da4:	f043 0302 	orr.w	r3, r3, #2
    1da8:	6033      	str	r3, [r6, #0]
    1daa:	bd70      	pop	{r4, r5, r6, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
   		return errBUFFER_NO_EXIST;                          				// Retorna indicando erro
    1dac:	f06f 000b 	mvn.w	r0, #11
    1db0:	bd70      	pop	{r4, r5, r6, pc}
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
   	}

  	return pdPASS;
    1db2:	2001      	movs	r0, #1
}
    1db4:	bd70      	pop	{r4, r5, r6, pc}
    1db6:	bf00      	nop
    1db8:	100006b8 	.word	0x100006b8
    1dbc:	4000c004 	.word	0x4000c004
    1dc0:	100006a6 	.word	0x100006a6
    1dc4:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_BasicPutChar:

00001dc8 <uart0_BasicPutChar>:
// Descrição:	Coloca um caractere na fila de transmissão. FUNÇÃO UTIL PARA DEBUG ONDE NÃO PRECISA INICIAR IRQ ou OS
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_BasicPutChar(n16 ch) {
  	while (!(U0LSR & U0LSR_THRE))								// Espero até que o buffer TX fique vazio
    1dc8:	4a04      	ldr	r2, [pc, #16]	; (1ddc <uart0_BasicPutChar+0x14>)
    1dca:	6813      	ldr	r3, [r2, #0]
    1dcc:	069b      	lsls	r3, r3, #26
    1dce:	d5fc      	bpl.n	1dca <uart0_BasicPutChar+0x2>
  		CRITICAL_WAIT;        									// Caso exista algum OS, pode trocar de contexto
  	U0THR = (u8)ch;												// Atualiza o registrador de TX uart com o dado
    1dd0:	4b03      	ldr	r3, [pc, #12]	; (1de0 <uart0_BasicPutChar+0x18>)
    1dd2:	b2c0      	uxtb	r0, r0
    1dd4:	6018      	str	r0, [r3, #0]
	return pdPASS;
}
    1dd6:	2001      	movs	r0, #1
    1dd8:	4770      	bx	lr
    1dda:	bf00      	nop
    1ddc:	4000c014 	.word	0x4000c014
    1de0:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_ISR:

00001de4 <uart0_ISR>:
//###################################################################################################################
// UART SERVIÇO DE INTERRUPÇÕES
// 		Descrição: 	Esta função implementa o ISR da UART0
//###################################################################################################################
//###################################################################################################################
void uart0_ISR (void) {
    1de4:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1de8:	4e23      	ldr	r6, [pc, #140]	; (1e78 <uart0_ISR+0x94>)
    1dea:	4c24      	ldr	r4, [pc, #144]	; (1e7c <uart0_ISR+0x98>)
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1dec:	4d24      	ldr	r5, [pc, #144]	; (1e80 <uart0_ISR+0x9c>)
void uart0_ISR (void) {
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1dee:	6833      	ldr	r3, [r6, #0]
    1df0:	b2db      	uxtb	r3, r3
    1df2:	07da      	lsls	r2, r3, #31
    1df4:	d43a      	bmi.n	1e6c <uart0_ISR+0x88>
    	switch (int_flags & U0IIR_ID_MASK) {									// Identifica a fonte de interrupção
    1df6:	f003 030e 	and.w	r3, r3, #14
    1dfa:	3b02      	subs	r3, #2
    1dfc:	2b0a      	cmp	r3, #10
    1dfe:	d831      	bhi.n	1e64 <uart0_ISR+0x80>
    1e00:	e8df f003 	tbb	[pc, r3]
    1e04:	3008301b 	.word	0x3008301b
    1e08:	30303006 	.word	0x30303006
    1e0c:	3030      	.short	0x3030
    1e0e:	08          	.byte	0x08
    1e0f:	00          	.byte	0x00
      	case U0IIR_RLS_INT:                									// Caso recebeu uma INT de erro na linha de recepção (receive line status)
        	U0LSR;                          								// Limpa registrador de status de linha
    1e10:	6823      	ldr	r3, [r4, #0]
        	break;
    1e12:	e7ec      	b.n	1dee <uart0_ISR+0xa>
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1e14:	f8df 8074 	ldr.w	r8, [pc, #116]	; 1e8c <uart0_ISR+0xa8>
					u0_overflow_rx++;
    1e18:	4f1a      	ldr	r7, [pc, #104]	; (1e84 <uart0_ISR+0xa0>)
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1e1a:	f8d8 1000 	ldr.w	r1, [r8]
    1e1e:	481a      	ldr	r0, [pc, #104]	; (1e88 <uart0_ISR+0xa4>)
    1e20:	b2c9      	uxtb	r1, r1
    1e22:	f000 fed8 	bl	2bd6 <buffer_AddToEnd>
    1e26:	300a      	adds	r0, #10
					u0_overflow_rx++;
    1e28:	bf01      	itttt	eq
    1e2a:	883b      	ldrheq	r3, [r7, #0]
    1e2c:	3301      	addeq	r3, #1
    1e2e:	b29b      	uxtheq	r3, r3
    1e30:	803b      	strheq	r3, [r7, #0]
      		} while(U0LSR & U0LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    1e32:	6823      	ldr	r3, [r4, #0]
    1e34:	07d8      	lsls	r0, r3, #31
    1e36:	d4f0      	bmi.n	1e1a <uart0_ISR+0x36>
    1e38:	e7d9      	b.n	1dee <uart0_ISR+0xa>
            		break;
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1e3a:	4f14      	ldr	r7, [pc, #80]	; (1e8c <uart0_ISR+0xa8>)

     	// RETIRA OS DADOS DO BUFFER TX PARA A FIFO DE TRANSMISSÃO
     		// Essa interrupção é gerada quando a FIFO de transmissão de 16 bytes está vazia
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
    1e3c:	6823      	ldr	r3, [r4, #0]
    1e3e:	0699      	lsls	r1, r3, #26
    1e40:	d5d5      	bpl.n	1dee <uart0_ISR+0xa>
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
    1e42:	4813      	ldr	r0, [pc, #76]	; (1e90 <uart0_ISR+0xac>)
    1e44:	f000 fee4 	bl	2c10 <buffer_IsEmpty>
    1e48:	b138      	cbz	r0, 1e5a <uart0_ISR+0x76>
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
    1e4a:	4b12      	ldr	r3, [pc, #72]	; (1e94 <uart0_ISR+0xb0>)
    1e4c:	2200      	movs	r2, #0
    1e4e:	701a      	strb	r2, [r3, #0]
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1e50:	682b      	ldr	r3, [r5, #0]
    1e52:	f023 0302 	bic.w	r3, r3, #2
    1e56:	602b      	str	r3, [r5, #0]
            		break;
    1e58:	e7c9      	b.n	1dee <uart0_ISR+0xa>
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1e5a:	480d      	ldr	r0, [pc, #52]	; (1e90 <uart0_ISR+0xac>)
    1e5c:	f000 fe99 	bl	2b92 <buffer_GetFromFront>
    1e60:	6038      	str	r0, [r7, #0]
    1e62:	e7eb      	b.n	1e3c <uart0_ISR+0x58>
          	}
		    
		    break;

      	default:															// Interrupção desconhecida
        	U0LSR;															// Limpa registrador de status de linha
    1e64:	6823      	ldr	r3, [r4, #0]
        	U0RBR;															// Limpa o registrador de recepçao de dados
    1e66:	4b09      	ldr	r3, [pc, #36]	; (1e8c <uart0_ISR+0xa8>)
    1e68:	681b      	ldr	r3, [r3, #0]
	       	break;
    1e6a:	e7c0      	b.n	1dee <uart0_ISR+0xa>
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e6c:	2005      	movs	r0, #5
	#endif

  	ISR_EXIT;																// Procedimento para saida da interrupção
}
    1e6e:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e72:	f7ff bde1 	b.w	1a38 <nvic_clearPendingIRQ>
    1e76:	bf00      	nop
    1e78:	4000c008 	.word	0x4000c008
    1e7c:	4000c014 	.word	0x4000c014
    1e80:	4000c004 	.word	0x4000c004
    1e84:	100006a8 	.word	0x100006a8
    1e88:	100006ac 	.word	0x100006ac
    1e8c:	4000c000 	.word	0x4000c000
    1e90:	100006b8 	.word	0x100006b8
    1e94:	100006a6 	.word	0x100006a6

Disassembly of section .text.showVicError:

00001e98 <showVicError>:
#include "vic.h"
#include "app.h"
#include "uart0_irq.h"

static void showVicError(int n) {
    1e98:	e92d 4888 	stmdb	sp!, {r3, r7, fp, lr}
	irq_Disable();
    1e9c:	b672      	cpsid	i
    1e9e:	280a      	cmp	r0, #10
    1ea0:	bfa8      	it	ge
    1ea2:	200a      	movge	r0, #10
    1ea4:	4604      	mov	r4, r0

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1ea6:	4d14      	ldr	r5, [pc, #80]	; (1ef8 <showVicError+0x60>)
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1ea8:	f8df 905c 	ldr.w	r9, [pc, #92]	; 1f08 <showVicError+0x70>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1eac:	f04f 0800 	mov.w	r8, #0
    1eb0:	f8df a044 	ldr.w	sl, [pc, #68]	; 1ef8 <showVicError+0x60>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1eb4:	f8df b054 	ldr.w	fp, [pc, #84]	; 1f0c <showVicError+0x74>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1eb8:	f8c5 8000 	str.w	r8, [r5]
    1ebc:	f8da 3000 	ldr.w	r3, [sl]
    1ec0:	429c      	cmp	r4, r3
    1ec2:	dd15      	ble.n	1ef0 <showVicError+0x58>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    1ec4:	f04f 5700 	mov.w	r7, #536870912	; 0x20000000
    1ec8:	f04f 46c0 	mov.w	r6, #1610612736	; 0x60000000
    1ecc:	f8c9 7000 	str.w	r7, [r9]
    1ed0:	480a      	ldr	r0, [pc, #40]	; (1efc <showVicError+0x64>)
    1ed2:	f8cb 6000 	str.w	r6, [fp]
    1ed6:	f7ff fe4d 	bl	1b74 <delay>
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
    1eda:	4b09      	ldr	r3, [pc, #36]	; (1f00 <showVicError+0x68>)
    1edc:	4807      	ldr	r0, [pc, #28]	; (1efc <showVicError+0x64>)
    1ede:	601f      	str	r7, [r3, #0]
    1ee0:	f843 6c80 	str.w	r6, [r3, #-128]
    1ee4:	f7ff fe46 	bl	1b74 <delay>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    1ee8:	682b      	ldr	r3, [r5, #0]
    1eea:	3301      	adds	r3, #1
    1eec:	602b      	str	r3, [r5, #0]
    1eee:	e7e5      	b.n	1ebc <showVicError+0x24>
			ledERROR_On();	buzzer_On();	delay_ms(250);
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
		}
		delay_ms(1000);
    1ef0:	4804      	ldr	r0, [pc, #16]	; (1f04 <showVicError+0x6c>)
    1ef2:	f7ff fe3f 	bl	1b74 <delay>
	}
    1ef6:	e7db      	b.n	1eb0 <showVicError+0x18>
    1ef8:	1000075c 	.word	0x1000075c
    1efc:	007f26c8 	.word	0x007f26c8
    1f00:	2009c09c 	.word	0x2009c09c
    1f04:	01fc9f08 	.word	0x01fc9f08
    1f08:	2009c098 	.word	0x2009c098
    1f0c:	2009c018 	.word	0x2009c018

Disassembly of section .text.startup.main:

00001f10 <main>:
}

int main(void) {
    1f10:	b508      	push	{r3, lr}
	nvic_SetIntHandler(showVicError);
    1f12:	4822      	ldr	r0, [pc, #136]	; (1f9c <main+0x8c>)
    1f14:	f7ff fdbe 	bl	1a94 <nvic_SetIntHandler>
	// NÃO USAR UART COM INTERRUPÇÃO PARA O LOG, POIS CONSTANTEMENTE A
  	// POSIÇÃO DOS VETORES DE INTERRUPÇÕES COM O USO DO BOOTLOADER

  	// REGISTRANDO AS ENTRADAS E SAÍDAS PADRÃO AOS SEUS RESPECTIVOS DISPOSTIVOS
	// PORTA PARA CLI DEVE SER COM INTERRUPÇÃO
  	lgetchar_RegisterDev(uart0_GetChar);
    1f18:	4821      	ldr	r0, [pc, #132]	; (1fa0 <main+0x90>)
    1f1a:	f000 fc57 	bl	27cc <lgetchar_RegisterDev>
	lputchar_RegisterDev(uart0_PutChar);
    1f1e:	4821      	ldr	r0, [pc, #132]	; (1fa4 <main+0x94>)
    1f20:	f000 fc48 	bl	27b4 <lputchar_RegisterDev>
	ldebug_RegisterDev(uart0_BasicPutChar);
    1f24:	4820      	ldr	r0, [pc, #128]	; (1fa8 <main+0x98>)
    1f26:	f000 fc4b 	bl	27c0 <ldebug_RegisterDev>
	uart0_Init(115200);
    1f2a:	f44f 30e1 	mov.w	r0, #115200	; 0x1c200
    1f2e:	f7ff fe9d 	bl	1c6c <uart0_Init>

	systime_Init();
    1f32:	f7ff fdb5 	bl	1aa0 <systime_Init>
	systime_SetIntHandler(app_Tick, 1); // Chamar o a função callsystem a cada 1ms OBS: Levando em consideração o SYSTIME_IRQ_TICK_DIV
    1f36:	2101      	movs	r1, #1
    1f38:	481c      	ldr	r0, [pc, #112]	; (1fac <main+0x9c>)
    1f3a:	f7ff fddf 	bl	1afc <systime_SetIntHandler>
	ledError_Init();
    1f3e:	f000 ff0b 	bl	2d58 <ledError_Init>
	beep_Init();
    1f42:	f001 f81d 	bl	2f80 <beep_Init>
	gKey_Init(onKeyDown, &onKeyPress, &onKeyUp);	// Anexar os eventos do teclado
    1f46:	4a1a      	ldr	r2, [pc, #104]	; (1fb0 <main+0xa0>)
    1f48:	491a      	ldr	r1, [pc, #104]	; (1fb4 <main+0xa4>)
    1f4a:	481b      	ldr	r0, [pc, #108]	; (1fb8 <main+0xa8>)
    1f4c:	f000 ff58 	bl	2e00 <gKey_Init>

	lcd_Init(16, 2, LCD_5x8DOTS);
    1f50:	2200      	movs	r2, #0
    1f52:	2102      	movs	r1, #2
    1f54:	2010      	movs	r0, #16
    1f56:	f001 fa57 	bl	3408 <lcd_Init>
	lcd_printfInit(16, STDIO_DEV1);
    1f5a:	2104      	movs	r1, #4
    1f5c:	2010      	movs	r0, #16
    1f5e:	f001 fac9 	bl	34f4 <lcd_printfInit>
	rprintf_RegisterDev(STDIO_DEV2, lcd_PutChar);								// Anexo a função ao printf
    1f62:	4916      	ldr	r1, [pc, #88]	; (1fbc <main+0xac>)
    1f64:	2005      	movs	r0, #5
    1f66:	f000 fc0d 	bl	2784 <rprintf_RegisterDev>

	irq_Enable(); 	// Habilitar interrupções
    1f6a:	b662      	cpsie	i
	app_Init();
    1f6c:	f000 f8c2 	bl	20f4 <app_Init>

	lprintf(CMD_TERMINATOR);
    1f70:	4913      	ldr	r1, [pc, #76]	; (1fc0 <main+0xb0>)
    1f72:	2001      	movs	r0, #1
    1f74:	f000 fdf2 	bl	2b5c <rprintf>
	lprintf(PROGAM_NAME);
    1f78:	4912      	ldr	r1, [pc, #72]	; (1fc4 <main+0xb4>)
    1f7a:	2001      	movs	r0, #1
    1f7c:	f000 fdee 	bl	2b5c <rprintf>
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);
    1f80:	4911      	ldr	r1, [pc, #68]	; (1fc8 <main+0xb8>)
    1f82:	2001      	movs	r0, #1
    1f84:	f000 fdea 	bl	2b5c <rprintf>

	while (1) {
		prompt_Process();
		app_Process();
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    1f88:	4c10      	ldr	r4, [pc, #64]	; (1fcc <main+0xbc>)
	lprintf(CMD_TERMINATOR);
	lprintf(PROGAM_NAME);
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);

	while (1) {
		prompt_Process();
    1f8a:	f000 fac3 	bl	2514 <prompt_Process>
		app_Process();
    1f8e:	f000 f999 	bl	22c4 <app_Process>
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    1f92:	7920      	ldrb	r0, [r4, #4]
    1f94:	f000 ff50 	bl	2e38 <gKey_Process>
    1f98:	e7f7      	b.n	1f8a <main+0x7a>
    1f9a:	bf00      	nop
    1f9c:	00001e99 	.word	0x00001e99
    1fa0:	00001d1d 	.word	0x00001d1d
    1fa4:	00001d61 	.word	0x00001d61
    1fa8:	00001dc9 	.word	0x00001dc9
    1fac:	00002221 	.word	0x00002221
    1fb0:	0000201d 	.word	0x0000201d
    1fb4:	00002005 	.word	0x00002005
    1fb8:	00001fd1 	.word	0x00001fd1
    1fbc:	00003393 	.word	0x00003393
    1fc0:	00003c77 	.word	0x00003c77
    1fc4:	00003bde 	.word	0x00003bde
    1fc8:	00003d74 	.word	0x00003d74
    1fcc:	100005d4 	.word	0x100005d4

Disassembly of section .text.onKeyDown:

00001fd0 <onKeyDown>:
#include "app.h"

// #######################################################################################################
// KEYBOARD
// #######################################################################################################
void onKeyDown(char key) {
    1fd0:	b510      	push	{r4, lr}
    1fd2:	4604      	mov	r4, r0
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
    1fd4:	4602      	mov	r2, r0
    1fd6:	490a      	ldr	r1, [pc, #40]	; (2000 <onKeyDown+0x30>)
    1fd8:	2001      	movs	r0, #1
    1fda:	f000 fdbf 	bl	2b5c <rprintf>
	if (key == SW0) beep_Play(4);
    1fde:	2c01      	cmp	r4, #1
    1fe0:	d101      	bne.n	1fe6 <onKeyDown+0x16>
    1fe2:	2004      	movs	r0, #4
    1fe4:	e006      	b.n	1ff4 <onKeyDown+0x24>
	else if (key == SW1) beep_Play(5);
    1fe6:	2c02      	cmp	r4, #2
    1fe8:	d101      	bne.n	1fee <onKeyDown+0x1e>
    1fea:	2005      	movs	r0, #5
    1fec:	e002      	b.n	1ff4 <onKeyDown+0x24>
	else if (key == SW2) beep_Play(6);
    1fee:	2c04      	cmp	r4, #4
    1ff0:	d104      	bne.n	1ffc <onKeyDown+0x2c>
    1ff2:	2006      	movs	r0, #6
}
    1ff4:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
// #######################################################################################################
void onKeyDown(char key) {
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
	if (key == SW0) beep_Play(4);
	else if (key == SW1) beep_Play(5);
	else if (key == SW2) beep_Play(6);
    1ff8:	f000 bfd8 	b.w	2fac <beep_Play>
    1ffc:	bd10      	pop	{r4, pc}
    1ffe:	bf00      	nop
    2000:	00003c1e 	.word	0x00003c1e

Disassembly of section .text.onKeyPress:

00002004 <onKeyPress>:
}

void onKeyPress(char key __attribute__ ((unused)) ) {
	lprintf("onKeyPress key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    2004:	4b03      	ldr	r3, [pc, #12]	; (2014 <onKeyPress+0x10>)
    2006:	4602      	mov	r2, r0
    2008:	681b      	ldr	r3, [r3, #0]
    200a:	4903      	ldr	r1, [pc, #12]	; (2018 <onKeyPress+0x14>)
    200c:	2001      	movs	r0, #1
    200e:	f000 bda5 	b.w	2b5c <rprintf>
    2012:	bf00      	nop
    2014:	100005ec 	.word	0x100005ec
    2018:	00003c34 	.word	0x00003c34

Disassembly of section .text.onKeyUp:

0000201c <onKeyUp>:
}

void onKeyUp(char key __attribute__ ((unused)) ) {
	lprintf("onKeyUp key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    201c:	4b03      	ldr	r3, [pc, #12]	; (202c <onKeyUp+0x10>)
    201e:	4602      	mov	r2, r0
    2020:	681b      	ldr	r3, [r3, #0]
    2022:	4903      	ldr	r1, [pc, #12]	; (2030 <onKeyUp+0x14>)
    2024:	2001      	movs	r0, #1
    2026:	f000 bd99 	b.w	2b5c <rprintf>
    202a:	bf00      	nop
    202c:	100005ec 	.word	0x100005ec
    2030:	00003c58 	.word	0x00003c58

Disassembly of section .text.relay_Init:

00002034 <relay_Init>:

// #######################################################################################################
// RELAYS
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
    2034:	4b07      	ldr	r3, [pc, #28]	; (2054 <relay_Init+0x20>)
    2036:	681a      	ldr	r2, [r3, #0]
    2038:	f042 4280 	orr.w	r2, r2, #1073741824	; 0x40000000
    203c:	601a      	str	r2, [r3, #0]
	relay2_Init();
    203e:	681a      	ldr	r2, [r3, #0]
    2040:	f042 4200 	orr.w	r2, r2, #2147483648	; 0x80000000
    2044:	601a      	str	r2, [r3, #0]

	control.relay1.st = 0;
    2046:	4b04      	ldr	r3, [pc, #16]	; (2058 <relay_Init+0x24>)
    2048:	2200      	movs	r2, #0
	control.relay1.timeout = 0;
    204a:	60da      	str	r2, [r3, #12]
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
	relay2_Init();

	control.relay1.st = 0;
    204c:	609a      	str	r2, [r3, #8]
	control.relay1.timeout = 0;

	control.relay2.st = 0;
    204e:	611a      	str	r2, [r3, #16]
	control.relay2.timeout = 0;
    2050:	615a      	str	r2, [r3, #20]
    2052:	4770      	bx	lr
    2054:	2009c020 	.word	0x2009c020
    2058:	100005d4 	.word	0x100005d4

Disassembly of section .text.relay_Set:

0000205c <relay_Set>:
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    205c:	2801      	cmp	r0, #1
// Liga ou desliga o rele
//	parametro rly: sinaliza qual o rele vamos acessar. valor 0 ou 1
//	parametro st: pdON liga o rele e pdOFF desliga o rele;
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
    205e:	b510      	push	{r4, lr}
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    2060:	d80d      	bhi.n	207e <relay_Set+0x22>
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;
    2062:	4b08      	ldr	r3, [pc, #32]	; (2084 <relay_Set+0x28>)
    2064:	f103 0408 	add.w	r4, r3, #8
    2068:	2800      	cmp	r0, #0
    206a:	bf0c      	ite	eq
    206c:	4618      	moveq	r0, r3
    206e:	4620      	movne	r0, r4

	rl->timeout = timeout*1000;
    2070:	f44f 737a 	mov.w	r3, #1000	; 0x3e8
    2074:	435a      	muls	r2, r3
	rl->st = st;
    2076:	6001      	str	r1, [r0, #0]
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;

	rl->timeout = timeout*1000;
    2078:	6042      	str	r2, [r0, #4]
	rl->st = st;

	return pdPASS;
    207a:	2001      	movs	r0, #1
    207c:	bd10      	pop	{r4, pc}
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    207e:	4802      	ldr	r0, [pc, #8]	; (2088 <relay_Set+0x2c>)

	rl->timeout = timeout*1000;
	rl->st = st;

	return pdPASS;
}
    2080:	bd10      	pop	{r4, pc}
    2082:	bf00      	nop
    2084:	100005dc 	.word	0x100005dc
    2088:	fffffed4 	.word	0xfffffed4

Disassembly of section .text.relay_Tick:

0000208c <relay_Tick>:

void relay_Tick(void) {
	if (control.relay1.st) relay1_On(); else relay1_Off();
    208c:	4b16      	ldr	r3, [pc, #88]	; (20e8 <relay_Tick+0x5c>)
	rl->st = st;

	return pdPASS;
}

void relay_Tick(void) {
    208e:	b510      	push	{r4, lr}
	if (control.relay1.st) relay1_On(); else relay1_Off();
    2090:	6899      	ldr	r1, [r3, #8]
    2092:	f04f 4280 	mov.w	r2, #1073741824	; 0x40000000
    2096:	b109      	cbz	r1, 209c <relay_Tick+0x10>
    2098:	4814      	ldr	r0, [pc, #80]	; (20ec <relay_Tick+0x60>)
    209a:	e000      	b.n	209e <relay_Tick+0x12>
    209c:	4814      	ldr	r0, [pc, #80]	; (20f0 <relay_Tick+0x64>)
    209e:	6002      	str	r2, [r0, #0]
	if (control.relay2.st) relay2_On(); else relay2_Off();
    20a0:	691a      	ldr	r2, [r3, #16]
    20a2:	f04f 4000 	mov.w	r0, #2147483648	; 0x80000000
    20a6:	b10a      	cbz	r2, 20ac <relay_Tick+0x20>
    20a8:	4c10      	ldr	r4, [pc, #64]	; (20ec <relay_Tick+0x60>)
    20aa:	e000      	b.n	20ae <relay_Tick+0x22>
    20ac:	4c10      	ldr	r4, [pc, #64]	; (20f0 <relay_Tick+0x64>)
    20ae:	6020      	str	r0, [r4, #0]
	if (control.relay1.timeout > 0) control.relay1.timeout--;
    20b0:	68d8      	ldr	r0, [r3, #12]
    20b2:	4c0d      	ldr	r4, [pc, #52]	; (20e8 <relay_Tick+0x5c>)
    20b4:	b110      	cbz	r0, 20bc <relay_Tick+0x30>
    20b6:	68e0      	ldr	r0, [r4, #12]
    20b8:	3801      	subs	r0, #1
    20ba:	60e0      	str	r0, [r4, #12]
	if (control.relay2.timeout > 0) control.relay2.timeout--;
    20bc:	6958      	ldr	r0, [r3, #20]
    20be:	4c0a      	ldr	r4, [pc, #40]	; (20e8 <relay_Tick+0x5c>)
    20c0:	b110      	cbz	r0, 20c8 <relay_Tick+0x3c>
    20c2:	6960      	ldr	r0, [r4, #20]
    20c4:	3801      	subs	r0, #1
    20c6:	6160      	str	r0, [r4, #20]
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    20c8:	68d8      	ldr	r0, [r3, #12]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    20ca:	695b      	ldr	r3, [r3, #20]
	if (control.relay1.st) relay1_On(); else relay1_Off();
	if (control.relay2.st) relay2_On(); else relay2_Off();
	if (control.relay1.timeout > 0) control.relay1.timeout--;
	if (control.relay2.timeout > 0) control.relay2.timeout--;
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    20cc:	2801      	cmp	r0, #1
    20ce:	bf02      	ittt	eq
    20d0:	4805      	ldreq	r0, [pc, #20]	; (20e8 <relay_Tick+0x5c>)
    20d2:	f081 0101 	eoreq.w	r1, r1, #1
    20d6:	6081      	streq	r1, [r0, #8]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    20d8:	2b01      	cmp	r3, #1
    20da:	bf02      	ittt	eq
    20dc:	4b02      	ldreq	r3, [pc, #8]	; (20e8 <relay_Tick+0x5c>)
    20de:	f082 0201 	eoreq.w	r2, r2, #1
    20e2:	611a      	streq	r2, [r3, #16]
    20e4:	bd10      	pop	{r4, pc}
    20e6:	bf00      	nop
    20e8:	100005d4 	.word	0x100005d4
    20ec:	2009c038 	.word	0x2009c038
    20f0:	2009c03c 	.word	0x2009c03c

Disassembly of section .text.app_Init:

000020f4 <app_Init>:
};

u8 sun[8] = {0b00000,0b10101,0b01110,0b11111,0b11111,0b01110,0b10101,0b00000};

void app_Init(void) {
	control.ticks = 0;
    20f4:	4b40      	ldr	r3, [pc, #256]	; (21f8 <app_Init+0x104>)
  0b01010
};

u8 sun[8] = {0b00000,0b10101,0b01110,0b11111,0b11111,0b01110,0b10101,0b00000};

void app_Init(void) {
    20f6:	b537      	push	{r0, r1, r2, r4, r5, lr}
	control.ticks = 0;
    20f8:	2400      	movs	r4, #0
    20fa:	601c      	str	r4, [r3, #0]
	control.key = 0;
    20fc:	711c      	strb	r4, [r3, #4]

	relay_Init();
    20fe:	f7ff ff99 	bl	2034 <relay_Init>
	led1_Init();
    2102:	4b3e      	ldr	r3, [pc, #248]	; (21fc <app_Init+0x108>)
	led4_Init();
	led5_Init();
	led6_Init();

	// create a new character
  	lcd_CreateChar(0, heart);
    2104:	4620      	mov	r0, r4
void app_Init(void) {
	control.ticks = 0;
	control.key = 0;

	relay_Init();
	led1_Init();
    2106:	681a      	ldr	r2, [r3, #0]
	led4_Init();
	led5_Init();
	led6_Init();

	// create a new character
  	lcd_CreateChar(0, heart);
    2108:	493d      	ldr	r1, [pc, #244]	; (2200 <app_Init+0x10c>)
void app_Init(void) {
	control.ticks = 0;
	control.key = 0;

	relay_Init();
	led1_Init();
    210a:	f042 0201 	orr.w	r2, r2, #1
    210e:	601a      	str	r2, [r3, #0]
	led2_Init();
    2110:	681a      	ldr	r2, [r3, #0]
  	lcd_CreateChar(4, armsUp);
  	// create a new character
  	lcd_CreateChar(5, sun);

  	lcd_SetCursor(0, 0);
  	rprintf(STDIO_DEV2, "Hello %d/%02d/%02d ", 2017,6,2);
    2112:	2502      	movs	r5, #2
	control.ticks = 0;
	control.key = 0;

	relay_Init();
	led1_Init();
	led2_Init();
    2114:	f042 0202 	orr.w	r2, r2, #2
    2118:	601a      	str	r2, [r3, #0]
	led3_Init();
    211a:	f853 2c20 	ldr.w	r2, [r3, #-32]
    211e:	f042 5280 	orr.w	r2, r2, #268435456	; 0x10000000
    2122:	f843 2c20 	str.w	r2, [r3, #-32]
	led4_Init();
    2126:	f853 2c20 	ldr.w	r2, [r3, #-32]
    212a:	f042 5200 	orr.w	r2, r2, #536870912	; 0x20000000
    212e:	f843 2c20 	str.w	r2, [r3, #-32]
	led5_Init();
    2132:	f853 2c20 	ldr.w	r2, [r3, #-32]
    2136:	f042 6280 	orr.w	r2, r2, #67108864	; 0x4000000
    213a:	f843 2c20 	str.w	r2, [r3, #-32]
	led6_Init();
    213e:	f853 2c20 	ldr.w	r2, [r3, #-32]
    2142:	f042 7200 	orr.w	r2, r2, #33554432	; 0x2000000
    2146:	f843 2c20 	str.w	r2, [r3, #-32]

	// create a new character
  	lcd_CreateChar(0, heart);
    214a:	f001 f9b5 	bl	34b8 <lcd_CreateChar>
  	// create a new character
  	lcd_CreateChar(1, smiley);
    214e:	492d      	ldr	r1, [pc, #180]	; (2204 <app_Init+0x110>)
    2150:	2001      	movs	r0, #1
    2152:	f001 f9b1 	bl	34b8 <lcd_CreateChar>
  	// create a new character
  	lcd_CreateChar(2, frownie);
    2156:	492c      	ldr	r1, [pc, #176]	; (2208 <app_Init+0x114>)
    2158:	2002      	movs	r0, #2
    215a:	f001 f9ad 	bl	34b8 <lcd_CreateChar>
  	// create a new character
  	lcd_CreateChar(3, armsDown);
    215e:	492b      	ldr	r1, [pc, #172]	; (220c <app_Init+0x118>)
    2160:	2003      	movs	r0, #3
    2162:	f001 f9a9 	bl	34b8 <lcd_CreateChar>
  	// create a new character
  	lcd_CreateChar(4, armsUp);
    2166:	492a      	ldr	r1, [pc, #168]	; (2210 <app_Init+0x11c>)
    2168:	2004      	movs	r0, #4
    216a:	f001 f9a5 	bl	34b8 <lcd_CreateChar>
  	// create a new character
  	lcd_CreateChar(5, sun);
    216e:	4929      	ldr	r1, [pc, #164]	; (2214 <app_Init+0x120>)
    2170:	2005      	movs	r0, #5
    2172:	f001 f9a1 	bl	34b8 <lcd_CreateChar>

  	lcd_SetCursor(0, 0);
    2176:	4621      	mov	r1, r4
    2178:	4620      	mov	r0, r4
    217a:	f001 f923 	bl	33c4 <lcd_SetCursor>
  	rprintf(STDIO_DEV2, "Hello %d/%02d/%02d ", 2017,6,2);
    217e:	2306      	movs	r3, #6
    2180:	f240 72e1 	movw	r2, #2017	; 0x7e1
    2184:	9500      	str	r5, [sp, #0]
    2186:	4924      	ldr	r1, [pc, #144]	; (2218 <app_Init+0x124>)
    2188:	2005      	movs	r0, #5
    218a:	f000 fce7 	bl	2b5c <rprintf>
  	lcd_SetCursor(0, 1);
    218e:	4620      	mov	r0, r4
    2190:	2101      	movs	r1, #1
    2192:	f001 f917 	bl	33c4 <lcd_SetCursor>
  	lcd_printf("FACES:%d =", 6);
    2196:	2106      	movs	r1, #6
    2198:	4820      	ldr	r0, [pc, #128]	; (221c <app_Init+0x128>)
    219a:	f001 f9bb 	bl	3514 <lcd_printf>

	lcd_SetCursor(10, 1);
    219e:	2101      	movs	r1, #1
    21a0:	200a      	movs	r0, #10
    21a2:	f001 f90f 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(0); // exibir padrão 1
    21a6:	4620      	mov	r0, r4
    21a8:	f001 f8f3 	bl	3392 <lcd_PutChar>
	lcd_SetCursor(11, 1);
    21ac:	2101      	movs	r1, #1
    21ae:	200b      	movs	r0, #11
    21b0:	f001 f908 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(1); // exibir padrão 2
    21b4:	2001      	movs	r0, #1
    21b6:	f001 f8ec 	bl	3392 <lcd_PutChar>
	lcd_SetCursor(12, 1);
    21ba:	2101      	movs	r1, #1
    21bc:	200c      	movs	r0, #12
    21be:	f001 f901 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(2); // exibir padrão 3
    21c2:	4628      	mov	r0, r5
    21c4:	f001 f8e5 	bl	3392 <lcd_PutChar>
	lcd_SetCursor(13, 1);
    21c8:	2101      	movs	r1, #1
    21ca:	200d      	movs	r0, #13
    21cc:	f001 f8fa 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(3); // exibir padrão 4
    21d0:	2003      	movs	r0, #3
    21d2:	f001 f8de 	bl	3392 <lcd_PutChar>
	lcd_SetCursor(14, 1);
    21d6:	2101      	movs	r1, #1
    21d8:	200e      	movs	r0, #14
    21da:	f001 f8f3 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(4); // exibir padrão 5
    21de:	2004      	movs	r0, #4
    21e0:	f001 f8d7 	bl	3392 <lcd_PutChar>
	lcd_SetCursor(15, 1);
    21e4:	2101      	movs	r1, #1
    21e6:	200f      	movs	r0, #15
    21e8:	f001 f8ec 	bl	33c4 <lcd_SetCursor>
	lcd_PutChar(5); // exibir padrão 6
    21ec:	2005      	movs	r0, #5
}
    21ee:	b003      	add	sp, #12
    21f0:	e8bd 4030 	ldmia.w	sp!, {r4, r5, lr}
	lcd_SetCursor(13, 1);
	lcd_PutChar(3); // exibir padrão 4
	lcd_SetCursor(14, 1);
	lcd_PutChar(4); // exibir padrão 5
	lcd_SetCursor(15, 1);
	lcd_PutChar(5); // exibir padrão 6
    21f4:	f001 b8cd 	b.w	3392 <lcd_PutChar>
    21f8:	100005d4 	.word	0x100005d4
    21fc:	2009c040 	.word	0x2009c040
    2200:	10000000 	.word	0x10000000
    2204:	10000024 	.word	0x10000024
    2208:	10000008 	.word	0x10000008
    220c:	1000002c 	.word	0x1000002c
    2210:	1000001c 	.word	0x1000001c
    2214:	10000014 	.word	0x10000014
    2218:	00003c79 	.word	0x00003c79
    221c:	00003c8d 	.word	0x00003c8d

Disassembly of section .text.app_Tick:

00002220 <app_Tick>:
}

// Aqui descre, ou chame, códigos que controlam tempos ou que sejam executados em tempos reguladores
void app_Tick(void) {
    2220:	b570      	push	{r4, r5, r6, lr}
	// ATENÇÃO:  tempo de execução de TODOS os TICKS dentro dessa função NÃO pode ser superior a 1ms
	ledError_Tick();
    2222:	f000 fda5 	bl	2d70 <ledError_Tick>
	beep_Tick();
    2226:	f000 fed3 	bl	2fd0 <beep_Tick>
	gKey_Tick();
    222a:	f000 fdfb 	bl	2e24 <gKey_Tick>
	relay_Tick();
    222e:	f7ff ff2d 	bl	208c <relay_Tick>

	// LEITURA DO TECLADO a cada 3ms
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
    2232:	4b1f      	ldr	r3, [pc, #124]	; (22b0 <app_Tick+0x90>)
    2234:	681a      	ldr	r2, [r3, #0]
    2236:	b112      	cbz	r2, 223e <app_Tick+0x1e>
    2238:	681a      	ldr	r2, [r3, #0]
    223a:	3a01      	subs	r2, #1
    223c:	601a      	str	r2, [r3, #0]
	if (timeReadKey == 0) {
    223e:	681b      	ldr	r3, [r3, #0]
    2240:	4c1c      	ldr	r4, [pc, #112]	; (22b4 <app_Tick+0x94>)
    2242:	2b00      	cmp	r3, #0
    2244:	d12f      	bne.n	22a6 <app_Tick+0x86>
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    2246:	481c      	ldr	r0, [pc, #112]	; (22b8 <app_Tick+0x98>)
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    2248:	4a19      	ldr	r2, [pc, #100]	; (22b0 <app_Tick+0x90>)

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    224a:	6801      	ldr	r1, [r0, #0]
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    224c:	2303      	movs	r3, #3
    224e:	6013      	str	r3, [r2, #0]

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    2250:	fbb1 f3f3 	udiv	r3, r1, r3
    2254:	4d19      	ldr	r5, [pc, #100]	; (22bc <app_Tick+0x9c>)
    2256:	eb03 0343 	add.w	r3, r3, r3, lsl #1
    225a:	1aca      	subs	r2, r1, r3
    225c:	682b      	ldr	r3, [r5, #0]
		bufKey[idx%3] |= (sw1_PIN&sw0_NUMPIN)?SW1:0;
    225e:	682e      	ldr	r6, [r5, #0]
		bufKey[idx%3] |= (sw2_PIN&sw0_NUMPIN)?SW2:0;
    2260:	682d      	ldr	r5, [r5, #0]
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw0_NUMPIN)?SW1:0;
    2262:	f016 7f80 	tst.w	r6, #16777216	; 0x1000000
    2266:	bf14      	ite	ne
    2268:	2602      	movne	r6, #2
    226a:	2600      	moveq	r6, #0
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    226c:	f3c3 6300 	ubfx	r3, r3, #24, #1
		bufKey[idx%3] |= (sw1_PIN&sw0_NUMPIN)?SW1:0;
		bufKey[idx%3] |= (sw2_PIN&sw0_NUMPIN)?SW2:0;
    2270:	f015 7f80 	tst.w	r5, #16777216	; 0x1000000
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw0_NUMPIN)?SW1:0;
    2274:	ea43 0306 	orr.w	r3, r3, r6
		bufKey[idx%3] |= (sw2_PIN&sw0_NUMPIN)?SW2:0;
    2278:	4d11      	ldr	r5, [pc, #68]	; (22c0 <app_Tick+0xa0>)
    227a:	bf14      	ite	ne
    227c:	2604      	movne	r6, #4
    227e:	2600      	moveq	r6, #0
    2280:	4333      	orrs	r3, r6
    2282:	f845 3022 	str.w	r3, [r5, r2, lsl #2]

		if ( (bufKey[0] == bufKey[1]) && (bufKey[1] == bufKey[2]) ) {
    2286:	682b      	ldr	r3, [r5, #0]
    2288:	686a      	ldr	r2, [r5, #4]
    228a:	4293      	cmp	r3, r2
    228c:	d105      	bne.n	229a <app_Tick+0x7a>
    228e:	68aa      	ldr	r2, [r5, #8]
    2290:	4293      	cmp	r3, r2
			control.key = bufKey[2]&0x7; // para que não pegar o botão de reconfigure
    2292:	bf04      	itt	eq
    2294:	f003 0307 	andeq.w	r3, r3, #7
    2298:	7123      	strbeq	r3, [r4, #4]
		}
		if (idx == 2) idx = 0; else idx++;
    229a:	2902      	cmp	r1, #2
    229c:	bf0b      	itete	eq
    229e:	2300      	moveq	r3, #0
    22a0:	3101      	addne	r1, #1
    22a2:	6003      	streq	r3, [r0, #0]
    22a4:	6001      	strne	r1, [r0, #0]
	}

	control.ticks++; // Contador de ticks do sistema
    22a6:	6823      	ldr	r3, [r4, #0]
    22a8:	3301      	adds	r3, #1
    22aa:	6023      	str	r3, [r4, #0]
    22ac:	bd70      	pop	{r4, r5, r6, pc}
    22ae:	bf00      	nop
    22b0:	10000770 	.word	0x10000770
    22b4:	100005d4 	.word	0x100005d4
    22b8:	10000774 	.word	0x10000774
    22bc:	2009c034 	.word	0x2009c034
    22c0:	10000764 	.word	0x10000764

Disassembly of section .text.app_Process:

000022c4 <app_Process>:

// Aqui descre, ou chame, códigos que não controlam tempos ou que não sejam executados em tempo reguladores, pelo menos diretamente
void app_Process(void) {
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
    22c4:	4b2a      	ldr	r3, [pc, #168]	; (2370 <app_Process+0xac>)
    22c6:	f44f 727a 	mov.w	r2, #1000	; 0x3e8
    22ca:	6818      	ldr	r0, [r3, #0]
	control.ticks++; // Contador de ticks do sistema
}


// Aqui descre, ou chame, códigos que não controlam tempos ou que não sejam executados em tempo reguladores, pelo menos diretamente
void app_Process(void) {
    22cc:	b510      	push	{r4, lr}
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
    22ce:	fbb0 f1f2 	udiv	r1, r0, r2
    22d2:	fb02 0211 	mls	r2, r2, r1, r0
    22d6:	2a00      	cmp	r2, #0
    22d8:	d148      	bne.n	236c <app_Process+0xa8>
    22da:	4a26      	ldr	r2, [pc, #152]	; (2374 <app_Process+0xb0>)
    22dc:	6818      	ldr	r0, [r3, #0]
    22de:	6811      	ldr	r1, [r2, #0]
    22e0:	4288      	cmp	r0, r1
    22e2:	d043      	beq.n	236c <app_Process+0xa8>
		ticks_d = control.ticks;
    22e4:	681b      	ldr	r3, [r3, #0]
    22e6:	4824      	ldr	r0, [pc, #144]	; (2378 <app_Process+0xb4>)
    22e8:	6013      	str	r3, [r2, #0]
		if (ledpos==0x01) led1_On(); else led1_Off();
    22ea:	4a24      	ldr	r2, [pc, #144]	; (237c <app_Process+0xb8>)
    22ec:	4924      	ldr	r1, [pc, #144]	; (2380 <app_Process+0xbc>)
    22ee:	6813      	ldr	r3, [r2, #0]
    22f0:	2b01      	cmp	r3, #1
    22f2:	d102      	bne.n	22fa <app_Process+0x36>
    22f4:	4c23      	ldr	r4, [pc, #140]	; (2384 <app_Process+0xc0>)
    22f6:	6023      	str	r3, [r4, #0]
    22f8:	e006      	b.n	2308 <app_Process+0x44>
    22fa:	2401      	movs	r4, #1
		if (ledpos==0x02) led2_On(); else led2_Off();
    22fc:	2b02      	cmp	r3, #2
void app_Process(void) {
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
    22fe:	6004      	str	r4, [r0, #0]
		if (ledpos==0x02) led2_On(); else led2_Off();
    2300:	d102      	bne.n	2308 <app_Process+0x44>
    2302:	4820      	ldr	r0, [pc, #128]	; (2384 <app_Process+0xc0>)
    2304:	6003      	str	r3, [r0, #0]
    2306:	e008      	b.n	231a <app_Process+0x56>
    2308:	2402      	movs	r4, #2
		if (ledpos==0x04) led3_On(); else led3_Off();
    230a:	2b04      	cmp	r3, #4
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
    230c:	6004      	str	r4, [r0, #0]
		if (ledpos==0x04) led3_On(); else led3_Off();
    230e:	d104      	bne.n	231a <app_Process+0x56>
    2310:	481d      	ldr	r0, [pc, #116]	; (2388 <app_Process+0xc4>)
    2312:	f04f 5480 	mov.w	r4, #268435456	; 0x10000000
    2316:	6004      	str	r4, [r0, #0]
    2318:	e009      	b.n	232e <app_Process+0x6a>
    231a:	f04f 5080 	mov.w	r0, #268435456	; 0x10000000
		if (ledpos==0x08) led4_On(); else led4_Off();
    231e:	2b08      	cmp	r3, #8
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
    2320:	6008      	str	r0, [r1, #0]
		if (ledpos==0x08) led4_On(); else led4_Off();
    2322:	d104      	bne.n	232e <app_Process+0x6a>
    2324:	4818      	ldr	r0, [pc, #96]	; (2388 <app_Process+0xc4>)
    2326:	f04f 5400 	mov.w	r4, #536870912	; 0x20000000
    232a:	6004      	str	r4, [r0, #0]
    232c:	e00b      	b.n	2346 <app_Process+0x82>
    232e:	f04f 5000 	mov.w	r0, #536870912	; 0x20000000
		if (ledpos==0x10) led5_On(); else led5_Off();
    2332:	2b10      	cmp	r3, #16
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
    2334:	6008      	str	r0, [r1, #0]
		if (ledpos==0x10) led5_On(); else led5_Off();
    2336:	d106      	bne.n	2346 <app_Process+0x82>
    2338:	f500 201c 	add.w	r0, r0, #638976	; 0x9c000
    233c:	f04f 6480 	mov.w	r4, #67108864	; 0x4000000
    2340:	3038      	adds	r0, #56	; 0x38
    2342:	6004      	str	r4, [r0, #0]
    2344:	e009      	b.n	235a <app_Process+0x96>
    2346:	f04f 6080 	mov.w	r0, #67108864	; 0x4000000
		if (ledpos==0x20) led6_On(); else led6_Off();
    234a:	2b20      	cmp	r3, #32
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
		if (ledpos==0x10) led5_On(); else led5_Off();
    234c:	6008      	str	r0, [r1, #0]
		if (ledpos==0x20) led6_On(); else led6_Off();
    234e:	d104      	bne.n	235a <app_Process+0x96>
    2350:	4b0d      	ldr	r3, [pc, #52]	; (2388 <app_Process+0xc4>)
    2352:	f04f 7100 	mov.w	r1, #33554432	; 0x2000000
    2356:	6019      	str	r1, [r3, #0]
    2358:	e006      	b.n	2368 <app_Process+0xa4>
    235a:	f04f 7000 	mov.w	r0, #33554432	; 0x2000000
		if (ledpos<0x20) ledpos<<=1; else ledpos=1;
    235e:	2b1f      	cmp	r3, #31
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
		if (ledpos==0x10) led5_On(); else led5_Off();
		if (ledpos==0x20) led6_On(); else led6_Off();
    2360:	6008      	str	r0, [r1, #0]
		if (ledpos<0x20) ledpos<<=1; else ledpos=1;
    2362:	d801      	bhi.n	2368 <app_Process+0xa4>
    2364:	005b      	lsls	r3, r3, #1
    2366:	e000      	b.n	236a <app_Process+0xa6>
    2368:	2301      	movs	r3, #1
    236a:	6013      	str	r3, [r2, #0]
    236c:	bd10      	pop	{r4, pc}
    236e:	bf00      	nop
    2370:	100005d4 	.word	0x100005d4
    2374:	10000760 	.word	0x10000760
    2378:	2009c05c 	.word	0x2009c05c
    237c:	10000010 	.word	0x10000010
    2380:	2009c03c 	.word	0x2009c03c
    2384:	2009c058 	.word	0x2009c058
    2388:	2009c038 	.word	0x2009c038

Disassembly of section .text.prompt_ClearTicks:

0000238c <prompt_ClearTicks>:

	return pdPASS;
}

static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
    238c:	4b02      	ldr	r3, [pc, #8]	; (2398 <prompt_ClearTicks+0xc>)
    238e:	2200      	movs	r2, #0
    2390:	601a      	str	r2, [r3, #0]
	return pdPASS;
}
    2392:	2001      	movs	r0, #1
    2394:	4770      	bx	lr
    2396:	bf00      	nop
    2398:	100005d4 	.word	0x100005d4

Disassembly of section .text.prompt_STS:

0000239c <prompt_STS>:
  	}

	return pdPASS;
}

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    239c:	b538      	push	{r3, r4, r5, lr}
	lprintf(CMD_TERMINATOR);
    239e:	4c13      	ldr	r4, [pc, #76]	; (23ec <prompt_STS+0x50>)
    23a0:	2001      	movs	r0, #1
    23a2:	4621      	mov	r1, r4
    23a4:	f000 fbda 	bl	2b5c <rprintf>
	lprintf(CMD_TERMINATOR);
    23a8:	4621      	mov	r1, r4
    23aa:	2001      	movs	r0, #1
    23ac:	f000 fbd6 	bl	2b5c <rprintf>
	lprintf("SYSTEM"CMD_TERMINATOR);
    23b0:	490f      	ldr	r1, [pc, #60]	; (23f0 <prompt_STS+0x54>)
    23b2:	2001      	movs	r0, #1
    23b4:	f000 fbd2 	bl	2b5c <rprintf>
	lprintf("    "PROGAM_NAME);
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    23b8:	4d0e      	ldr	r5, [pc, #56]	; (23f4 <prompt_STS+0x58>)

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	lprintf(CMD_TERMINATOR);
	lprintf(CMD_TERMINATOR);
	lprintf("SYSTEM"CMD_TERMINATOR);
	lprintf("    "PROGAM_NAME);
    23ba:	490f      	ldr	r1, [pc, #60]	; (23f8 <prompt_STS+0x5c>)
    23bc:	2001      	movs	r0, #1
    23be:	f000 fbcd 	bl	2b5c <rprintf>
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
    23c2:	490e      	ldr	r1, [pc, #56]	; (23fc <prompt_STS+0x60>)
    23c4:	2001      	movs	r0, #1
    23c6:	f000 fbc9 	bl	2b5c <rprintf>
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    23ca:	682a      	ldr	r2, [r5, #0]
    23cc:	490c      	ldr	r1, [pc, #48]	; (2400 <prompt_STS+0x64>)
    23ce:	2001      	movs	r0, #1
    23d0:	f000 fbc4 	bl	2b5c <rprintf>
	lprintf("    key pressing: %u"CMD_TERMINATOR, control.key);
    23d4:	792a      	ldrb	r2, [r5, #4]
    23d6:	490b      	ldr	r1, [pc, #44]	; (2404 <prompt_STS+0x68>)
    23d8:	2001      	movs	r0, #1
    23da:	f000 fbbf 	bl	2b5c <rprintf>
	lprintf(CMD_TERMINATOR);
    23de:	4621      	mov	r1, r4
    23e0:	2001      	movs	r0, #1
    23e2:	f000 fbbb 	bl	2b5c <rprintf>

	return pdPASS;
}
    23e6:	2001      	movs	r0, #1
    23e8:	bd38      	pop	{r3, r4, r5, pc}
    23ea:	bf00      	nop
    23ec:	00003c77 	.word	0x00003c77
    23f0:	00003d24 	.word	0x00003d24
    23f4:	100005d4 	.word	0x100005d4
    23f8:	00003d2c 	.word	0x00003d2c
    23fc:	00003d70 	.word	0x00003d70
    2400:	00003d88 	.word	0x00003d88
    2404:	00003d9d 	.word	0x00003d9d

Disassembly of section .text.prompt_Dump:

00002408 <prompt_Dump>:
static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
	return pdPASS;
}

static int prompt_Dump (int argc __attribute__ ((unused)), portCHAR **argv ) {
    2408:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
    240a:	460c      	mov	r4, r1
	long p1, p2;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    240c:	4669      	mov	r1, sp
    240e:	4620      	mov	r0, r4
    2410:	f000 fc4e 	bl	2cb0 <xatoi>
    2414:	b908      	cbnz	r0, 241a <prompt_Dump+0x12>
    2416:	2000      	movs	r0, #0
    2418:	e039      	b.n	248e <prompt_Dump+0x86>
	if (!xatoi(&argv[1], &p2)) return pdFAIL;
    241a:	a901      	add	r1, sp, #4
    241c:	1d20      	adds	r0, r4, #4
    241e:	f000 fc47 	bl	2cb0 <xatoi>
    2422:	2800      	cmp	r0, #0
    2424:	d0f7      	beq.n	2416 <prompt_Dump+0xe>

	if (p1 < 0) p1 = 0;
    2426:	9b00      	ldr	r3, [sp, #0]
    2428:	2b00      	cmp	r3, #0
    242a:	bfbc      	itt	lt
    242c:	2300      	movlt	r3, #0
    242e:	9300      	strlt	r3, [sp, #0]
	if (p2 < 1) p2 = 256;
    2430:	9b01      	ldr	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
    2432:	9d00      	ldr	r5, [sp, #0]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (!xatoi(&argv[1], &p2)) return pdFAIL;

	if (p1 < 0) p1 = 0;
	if (p2 < 1) p2 = 256;
    2434:	2b00      	cmp	r3, #0
    2436:	bfdc      	itt	le
    2438:	f44f 7380 	movle.w	r3, #256	; 0x100
    243c:	9301      	strle	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
	u16 qtd_rd = p2;
    243e:	f8bd 4004 	ldrh.w	r4, [sp, #4]

	while (qtd_rd) {
    2442:	b31c      	cbz	r4, 248c <prompt_Dump+0x84>
  		if (qtd_rd >= 16)
    2444:	2c0f      	cmp	r4, #15
    2446:	d91a      	bls.n	247e <prompt_Dump+0x76>
    2448:	462e      	mov	r6, r5
    244a:	192f      	adds	r7, r5, r4
    244c:	b2bf      	uxth	r7, r7
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
  				put_dump16(ptr, p1, 16, 16);
    244e:	2310      	movs	r3, #16
    2450:	461a      	mov	r2, r3
    2452:	4630      	mov	r0, r6
    2454:	9900      	ldr	r1, [sp, #0]
    2456:	f000 fbe1 	bl	2c1c <put_dump16>
	u16 qtd_rd = p2;

	while (qtd_rd) {
  		if (qtd_rd >= 16)
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
    245a:	9b00      	ldr	r3, [sp, #0]
    245c:	3610      	adds	r6, #16
    245e:	3310      	adds	r3, #16
    2460:	9300      	str	r3, [sp, #0]
    2462:	1bbb      	subs	r3, r7, r6
    2464:	b29b      	uxth	r3, r3
    2466:	2b0f      	cmp	r3, #15
    2468:	d8f1      	bhi.n	244e <prompt_Dump+0x46>
    246a:	f1a4 0310 	sub.w	r3, r4, #16
    246e:	f3c3 130b 	ubfx	r3, r3, #4, #12
    2472:	3301      	adds	r3, #1
  				put_dump16(ptr, p1, 16, 16);

		if (qtd_rd)
    2474:	f014 040f 	ands.w	r4, r4, #15
    2478:	eb05 1503 	add.w	r5, r5, r3, lsl #4
    247c:	d006      	beq.n	248c <prompt_Dump+0x84>
			put_dump16(ptr, p1, qtd_rd, 16);
    247e:	2310      	movs	r3, #16
    2480:	4622      	mov	r2, r4
    2482:	9900      	ldr	r1, [sp, #0]
    2484:	4628      	mov	r0, r5
    2486:	f000 fbc9 	bl	2c1c <put_dump16>
    248a:	e7da      	b.n	2442 <prompt_Dump+0x3a>
  	}

	return pdPASS;
    248c:	2001      	movs	r0, #1
}
    248e:	b003      	add	sp, #12
    2490:	bdf0      	pop	{r4, r5, r6, r7, pc}

Disassembly of section .text.prompt_Beep:

00002492 <prompt_Beep>:
  	} else result_prompt = pdPASS;

	return result_prompt;
}

static int prompt_Beep(int argc __attribute__ ((unused)), portCHAR **argv) {
    2492:	b507      	push	{r0, r1, r2, lr}
    2494:	4608      	mov	r0, r1
	long p1;
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2496:	a901      	add	r1, sp, #4
    2498:	f000 fc0a 	bl	2cb0 <xatoi>
    249c:	b118      	cbz	r0, 24a6 <prompt_Beep+0x14>
	beep_Play(p1);
    249e:	9801      	ldr	r0, [sp, #4]
    24a0:	f000 fd84 	bl	2fac <beep_Play>
	return pdPASS;
    24a4:	2001      	movs	r0, #1
}
    24a6:	b003      	add	sp, #12
    24a8:	f85d fb04 	ldr.w	pc, [sp], #4

Disassembly of section .text.prompt_Relay:

000024ac <prompt_Relay>:

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    24ac:	b573      	push	{r0, r1, r4, r5, r6, lr}
    24ae:	460c      	mov	r4, r1
	long p1=0, p2=0, p3=0;
    24b0:	2300      	movs	r3, #0
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    24b2:	4606      	mov	r6, r0
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    24b4:	4669      	mov	r1, sp
    24b6:	4620      	mov	r0, r4
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;
    24b8:	9300      	str	r3, [sp, #0]
    24ba:	9301      	str	r3, [sp, #4]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    24bc:	f000 fbf8 	bl	2cb0 <xatoi>
    24c0:	b908      	cbnz	r0, 24c6 <prompt_Relay+0x1a>
    24c2:	2000      	movs	r0, #0
    24c4:	e020      	b.n	2508 <prompt_Relay+0x5c>
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    24c6:	4911      	ldr	r1, [pc, #68]	; (250c <prompt_Relay+0x60>)
    24c8:	6860      	ldr	r0, [r4, #4]
    24ca:	f7fe fdef 	bl	10ac <strcmp>
    24ce:	fab0 f580 	clz	r5, r0
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    24d2:	2e02      	cmp	r6, #2

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    24d4:	ea4f 1555 	mov.w	r5, r5, lsr #5
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    24d8:	dc0d      	bgt.n	24f6 <prompt_Relay+0x4a>

	int ret = relay_Set(p1-1, p2, p3);
    24da:	9800      	ldr	r0, [sp, #0]
    24dc:	9a01      	ldr	r2, [sp, #4]
    24de:	4629      	mov	r1, r5
    24e0:	3801      	subs	r0, #1
    24e2:	f7ff fdbb 	bl	205c <relay_Set>

	if (ret == errDEVICE_NOT_FOUND)
    24e6:	f510 7f96 	cmn.w	r0, #300	; 0x12c
    24ea:	d10c      	bne.n	2506 <prompt_Relay+0x5a>
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    24ec:	4908      	ldr	r1, [pc, #32]	; (2510 <prompt_Relay+0x64>)
    24ee:	2001      	movs	r0, #1
    24f0:	f000 fb34 	bl	2b5c <rprintf>
    24f4:	e007      	b.n	2506 <prompt_Relay+0x5a>
static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    24f6:	a901      	add	r1, sp, #4
    24f8:	f104 0008 	add.w	r0, r4, #8
    24fc:	f000 fbd8 	bl	2cb0 <xatoi>
    2500:	2800      	cmp	r0, #0
    2502:	d1ea      	bne.n	24da <prompt_Relay+0x2e>
    2504:	e7dd      	b.n	24c2 <prompt_Relay+0x16>

	int ret = relay_Set(p1-1, p2, p3);

	if (ret == errDEVICE_NOT_FOUND)
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    2506:	2001      	movs	r0, #1

	return pdPASS;
}
    2508:	b002      	add	sp, #8
    250a:	bd70      	pop	{r4, r5, r6, pc}
    250c:	000039c8 	.word	0x000039c8
    2510:	00003db3 	.word	0x00003db3

Disassembly of section .text.prompt_Process:

00002514 <prompt_Process>:
	{ NULL, 0,  0, CMD_TYPE_FUNCTION,  	{ NULL },
			NULL,
			NULL },
};

void prompt_Process(void) {
    2514:	b570      	push	{r4, r5, r6, lr}
static portCHAR *argv_prompt [CLI_N_ARGS];
static int argc_prompt;

static int prompt_ProcessCommand(void) {
	// CAPTURA COMANDOS DO TERMINAL. SE TECLOU ENTER A FUNÇÃO RETORNA COM A QUANTIDADE DE CHAR DO COMANDO
	result_prompt = cli_GetLine (buffer_prompt, sizeof (buffer_prompt), PROMPT); // Chamo o console para entrada de comandos
    2516:	4a18      	ldr	r2, [pc, #96]	; (2578 <prompt_Process+0x64>)
    2518:	2128      	movs	r1, #40	; 0x28
    251a:	4818      	ldr	r0, [pc, #96]	; (257c <prompt_Process+0x68>)
    251c:	f000 fd9e 	bl	305c <cli_GetLine>
    2520:	4c17      	ldr	r4, [pc, #92]	; (2580 <prompt_Process+0x6c>)
    2522:	6020      	str	r0, [r4, #0]

	// CHECA FOI ENTRADO COM O COMANDO
	if (result_prompt) {	// checa se há entrada de comandos
    2524:	b198      	cbz	r0, 254e <prompt_Process+0x3a>
   		if (cli_ArgsParse ((char *) buffer_prompt, argv_prompt, sizeof (argv_prompt), &argc_prompt) == errCLI_EXED_ARGS) // Captura os endereços iniciais de cada argumento, contidos no comando, e grava nas posições do argv
    2526:	4e17      	ldr	r6, [pc, #92]	; (2584 <prompt_Process+0x70>)
    2528:	4d17      	ldr	r5, [pc, #92]	; (2588 <prompt_Process+0x74>)
    252a:	4633      	mov	r3, r6
    252c:	2228      	movs	r2, #40	; 0x28
    252e:	4629      	mov	r1, r5
    2530:	4812      	ldr	r0, [pc, #72]	; (257c <prompt_Process+0x68>)
    2532:	f000 fe59 	bl	31e8 <cli_ArgsParse>
    2536:	f110 0f3c 	cmn.w	r0, #60	; 0x3c
    253a:	d006      	beq.n	254a <prompt_Process+0x36>
   			result_prompt = errCLI_EXED_ARGS;
   		else if (argv_prompt[0])
    253c:	682b      	ldr	r3, [r5, #0]
    253e:	b143      	cbz	r3, 2552 <prompt_Process+0x3e>
   			result_prompt = cli_ArgsDispatch(cli_list, argc_prompt, &argv_prompt[0]);							// Executa a função referente ao comando digitado
    2540:	462a      	mov	r2, r5
    2542:	6831      	ldr	r1, [r6, #0]
    2544:	4811      	ldr	r0, [pc, #68]	; (258c <prompt_Process+0x78>)
    2546:	f000 fec7 	bl	32d8 <cli_ArgsDispatch>
    254a:	6020      	str	r0, [r4, #0]
    254c:	e001      	b.n	2552 <prompt_Process+0x3e>
  	} else result_prompt = pdPASS;
    254e:	2301      	movs	r3, #1
    2550:	6023      	str	r3, [r4, #0]
};

void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
    2552:	6823      	ldr	r3, [r4, #0]
    2554:	f113 0f3c 	cmn.w	r3, #60	; 0x3c
    2558:	d004      	beq.n	2564 <prompt_Process+0x50>
    255a:	b12b      	cbz	r3, 2568 <prompt_Process+0x54>
    255c:	333f      	adds	r3, #63	; 0x3f
    255e:	d109      	bne.n	2574 <prompt_Process+0x60>
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    2560:	490b      	ldr	r1, [pc, #44]	; (2590 <prompt_Process+0x7c>)
    2562:	e002      	b.n	256a <prompt_Process+0x56>
void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
    2564:	490b      	ldr	r1, [pc, #44]	; (2594 <prompt_Process+0x80>)
    2566:	e000      	b.n	256a <prompt_Process+0x56>
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2568:	490b      	ldr	r1, [pc, #44]	; (2598 <prompt_Process+0x84>)
    256a:	2001      	movs	r0, #1
    	break;
    }
}
    256c:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2570:	f000 baf4 	b.w	2b5c <rprintf>
    2574:	bd70      	pop	{r4, r5, r6, pc}
    2576:	bf00      	nop
    2578:	00003dd0 	.word	0x00003dd0
    257c:	100007a8 	.word	0x100007a8
    2580:	1000077c 	.word	0x1000077c
    2584:	10000778 	.word	0x10000778
    2588:	10000780 	.word	0x10000780
    258c:	00003c98 	.word	0x00003c98
    2590:	00003de2 	.word	0x00003de2
    2594:	00003dd4 	.word	0x00003dd4
    2598:	00003df3 	.word	0x00003df3

Disassembly of section .text.print_putchar:

0000259c <print_putchar>:
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    259c:	6802      	ldr	r2, [r0, #0]
// #######################################################################################################################
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
    259e:	b538      	push	{r3, r4, r5, lr}
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    25a0:	b122      	cbz	r2, 25ac <print_putchar+0x10>
		output->buf[output->count++] = c;
    25a2:	6843      	ldr	r3, [r0, #4]
    25a4:	1c5c      	adds	r4, r3, #1
    25a6:	6044      	str	r4, [r0, #4]
    25a8:	54d1      	strb	r1, [r2, r3]
		return;		// se é somente para fazer formatação de string não vamos fazer impressão em dispositivo
    25aa:	bd38      	pop	{r3, r4, r5, pc}
	#if defined(LINUX)
	stdio_putc(c);
	#else
	static int (*putcharfunc)(n16 c);
	
	switch(output->device) {
    25ac:	7b03      	ldrb	r3, [r0, #12]
    25ae:	4c10      	ldr	r4, [pc, #64]	; (25f0 <print_putchar+0x54>)
    25b0:	3b01      	subs	r3, #1
    25b2:	2b06      	cmp	r3, #6
    25b4:	d814      	bhi.n	25e0 <print_putchar+0x44>
    25b6:	e8df f003 	tbb	[pc, r3]
    25ba:	0604      	.short	0x0604
    25bc:	0e0c0a08 	.word	0x0e0c0a08
    25c0:	10          	.byte	0x10
    25c1:	00          	.byte	0x00
		case STDIO_LPRINTF:	putcharfunc = stdio_putc; break;
    25c2:	4b0c      	ldr	r3, [pc, #48]	; (25f4 <print_putchar+0x58>)
    25c4:	e00a      	b.n	25dc <print_putchar+0x40>
		case STDIO_DEBUG:	putcharfunc = debug_putc; break;
    25c6:	4b0c      	ldr	r3, [pc, #48]	; (25f8 <print_putchar+0x5c>)
    25c8:	e008      	b.n	25dc <print_putchar+0x40>
		case STDIO_ERROR:	putcharfunc = err_putc; break;
    25ca:	4b0c      	ldr	r3, [pc, #48]	; (25fc <print_putchar+0x60>)
    25cc:	e006      	b.n	25dc <print_putchar+0x40>
		case STDIO_DEV1: 	putcharfunc = dev1_putc; break;
    25ce:	4b0c      	ldr	r3, [pc, #48]	; (2600 <print_putchar+0x64>)
    25d0:	e004      	b.n	25dc <print_putchar+0x40>
   		case STDIO_DEV2: 	putcharfunc = dev2_putc; break;
    25d2:	4b0c      	ldr	r3, [pc, #48]	; (2604 <print_putchar+0x68>)
    25d4:	e002      	b.n	25dc <print_putchar+0x40>
   		case STDIO_DEV3: 	putcharfunc = dev3_putc; break;
    25d6:	4b0c      	ldr	r3, [pc, #48]	; (2608 <print_putchar+0x6c>)
    25d8:	e000      	b.n	25dc <print_putchar+0x40>
   		case STDIO_DEV4: 	putcharfunc = dev4_putc; break;
    25da:	4b0c      	ldr	r3, [pc, #48]	; (260c <print_putchar+0x70>)
    25dc:	681b      	ldr	r3, [r3, #0]
    25de:	6023      	str	r3, [r4, #0]
  	}

	// senão joga na porta de saida
	// Espera até que consiga incluir o caractere no buffer de TX
	while (putcharfunc(c) < 0) continue;
    25e0:	b20d      	sxth	r5, r1
    25e2:	6823      	ldr	r3, [r4, #0]
    25e4:	4628      	mov	r0, r5
    25e6:	4798      	blx	r3
    25e8:	2800      	cmp	r0, #0
    25ea:	dbfa      	blt.n	25e2 <print_putchar+0x46>
    25ec:	bd38      	pop	{r3, r4, r5, pc}
    25ee:	bf00      	nop
    25f0:	100007e4 	.word	0x100007e4
    25f4:	100007d8 	.word	0x100007d8
    25f8:	100007ec 	.word	0x100007ec
    25fc:	100007f0 	.word	0x100007f0
    2600:	100007d0 	.word	0x100007d0
    2604:	100007d4 	.word	0x100007d4
    2608:	100007e0 	.word	0x100007e0
    260c:	100007dc 	.word	0x100007dc

Disassembly of section .text.print_fill:

00002610 <print_fill>:
// #######################################################################################################################

//completa a impressao com os caracteres desejados
//n=quantos caracteres ja serao impressos, o que faltar
//a rotina preenche
static void print_fill(pPrint output, int n) {
    2610:	b538      	push	{r3, r4, r5, lr}
    2612:	4605      	mov	r5, r0
    2614:	7a04      	ldrb	r4, [r0, #8]
    2616:	1a64      	subs	r4, r4, r1
	n = output->prefix - n;
	while (n-->0) print_putchar(output, output->fill);
    2618:	2c00      	cmp	r4, #0
    261a:	dd05      	ble.n	2628 <print_fill+0x18>
    261c:	7a69      	ldrb	r1, [r5, #9]
    261e:	4628      	mov	r0, r5
    2620:	f7ff ffbc 	bl	259c <print_putchar>
    2624:	3c01      	subs	r4, #1
    2626:	e7f7      	b.n	2618 <print_fill+0x8>
}
    2628:	bd38      	pop	{r3, r4, r5, pc}

Disassembly of section .text.print_int:

0000262a <print_int>:
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    262a:	b570      	push	{r4, r5, r6, lr}
    262c:	4605      	mov	r5, r0
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    262e:	2900      	cmp	r1, #0
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    2630:	b090      	sub	sp, #64	; 0x40
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    2632:	bfba      	itte	lt
    2634:	4249      	neglt	r1, r1
    2636:	2201      	movlt	r2, #1
    2638:	2200      	movge	r2, #0
	d = 0;
    263a:	2300      	movs	r3, #0
	do	{
		digits[d++] = '0' + x%10;
    263c:	260a      	movs	r6, #10
    263e:	fb91 f0f6 	sdiv	r0, r1, r6
    2642:	fb06 1110 	mls	r1, r6, r0, r1
    2646:	3130      	adds	r1, #48	; 0x30
    2648:	f80d 1003 	strb.w	r1, [sp, r3]
    264c:	1c5c      	adds	r4, r3, #1
		x = x/10;
	}while (x);
    264e:	4601      	mov	r1, r0
    2650:	b108      	cbz	r0, 2656 <print_int+0x2c>
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    2652:	4623      	mov	r3, r4
    2654:	e7f3      	b.n	263e <print_int+0x14>
		x = x/10;
	}while (x);
	if (sig) digits[d++] = '-';
    2656:	b12a      	cbz	r2, 2664 <print_int+0x3a>
    2658:	aa10      	add	r2, sp, #64	; 0x40
    265a:	4414      	add	r4, r2
    265c:	222d      	movs	r2, #45	; 0x2d
    265e:	f804 2c40 	strb.w	r2, [r4, #-64]
    2662:	1c9c      	adds	r4, r3, #2

	print_fill(output, d);
    2664:	4621      	mov	r1, r4
    2666:	4628      	mov	r0, r5
    2668:	f7ff ffd2 	bl	2610 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    266c:	f114 34ff 	adds.w	r4, r4, #4294967295
    2670:	d305      	bcc.n	267e <print_int+0x54>
    2672:	f81d 1004 	ldrb.w	r1, [sp, r4]
    2676:	4628      	mov	r0, r5
    2678:	f7ff ff90 	bl	259c <print_putchar>
    267c:	e7f6      	b.n	266c <print_int+0x42>
}
    267e:	b010      	add	sp, #64	; 0x40
    2680:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_long:

00002682 <print_long>:

static void print_long(pPrint output, long x) {
    2682:	b570      	push	{r4, r5, r6, lr}
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    2684:	1e0c      	subs	r4, r1, #0

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    2686:	b090      	sub	sp, #64	; 0x40
    2688:	4606      	mov	r6, r0
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    268a:	da03      	bge.n	2694 <print_long+0x12>
    268c:	212d      	movs	r1, #45	; 0x2d
    268e:	f7ff ff85 	bl	259c <print_putchar>
    2692:	4264      	negs	r4, r4

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    2694:	2500      	movs	r5, #0
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    2696:	220a      	movs	r2, #10
    2698:	fb94 f3f2 	sdiv	r3, r4, r2
    269c:	fb02 4413 	mls	r4, r2, r3, r4
    26a0:	3501      	adds	r5, #1
    26a2:	3430      	adds	r4, #48	; 0x30
    26a4:	eb0d 0105 	add.w	r1, sp, r5
    26a8:	f801 4c01 	strb.w	r4, [r1, #-1]
		x = x/10;
	}while (x);
    26ac:	461c      	mov	r4, r3
    26ae:	2b00      	cmp	r3, #0
    26b0:	d1f2      	bne.n	2698 <print_long+0x16>

	print_fill(output, d);
    26b2:	4629      	mov	r1, r5
    26b4:	4630      	mov	r0, r6
    26b6:	f7ff ffab 	bl	2610 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    26ba:	f115 35ff 	adds.w	r5, r5, #4294967295
    26be:	d305      	bcc.n	26cc <print_long+0x4a>
    26c0:	f81d 1005 	ldrb.w	r1, [sp, r5]
    26c4:	4630      	mov	r0, r6
    26c6:	f7ff ff69 	bl	259c <print_putchar>
    26ca:	e7f6      	b.n	26ba <print_long+0x38>
}
    26cc:	b010      	add	sp, #64	; 0x40
    26ce:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_float:

000026d0 <print_float>:
	print_int(output, s);
}
#endif

#if ( STDIO_USE_FLOAT == pdON )
static void print_float(pPrint output, double x) {
    26d0:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    26d2:	4616      	mov	r6, r2
    26d4:	461d      	mov	r5, r3
    26d6:	4604      	mov	r4, r0
	if (x<0) { print_putchar(output, '-'); x = -x; }
    26d8:	2200      	movs	r2, #0
    26da:	2300      	movs	r3, #0
    26dc:	4630      	mov	r0, r6
    26de:	4629      	mov	r1, r5
    26e0:	f7fe fa36 	bl	b50 <__aeabi_dcmplt>
    26e4:	b128      	cbz	r0, 26f2 <print_float+0x22>
    26e6:	212d      	movs	r1, #45	; 0x2d
    26e8:	4620      	mov	r0, r4
    26ea:	f7ff ff57 	bl	259c <print_putchar>
    26ee:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	//parte inteira
	print_long(output, (long)x);
    26f2:	4629      	mov	r1, r5
    26f4:	4630      	mov	r0, r6
    26f6:	f7fe fa53 	bl	ba0 <__aeabi_d2iz>
    26fa:	4601      	mov	r1, r0
    26fc:	4607      	mov	r7, r0
    26fe:	4620      	mov	r0, r4
    2700:	f7ff ffbf 	bl	2682 <print_long>
	if (output->precision<=0) return;
    2704:	7aa3      	ldrb	r3, [r4, #10]
    2706:	b3bb      	cbz	r3, 2778 <print_float+0xa8>
	//parte fracionaria
	print_putchar(output, '.');
    2708:	212e      	movs	r1, #46	; 0x2e
    270a:	4620      	mov	r0, r4
    270c:	f7ff ff46 	bl	259c <print_putchar>
	output->prefix = 0;
    2710:	2300      	movs	r3, #0
    2712:	7223      	strb	r3, [r4, #8]
	x = x - (int)(x);
    2714:	4638      	mov	r0, r7
    2716:	f7fd ff43 	bl	5a0 <__aeabi_i2d>
    271a:	4602      	mov	r2, r0
    271c:	460b      	mov	r3, r1
    271e:	4630      	mov	r0, r6
    2720:	4629      	mov	r1, r5
    2722:	f7fd fdef 	bl	304 <__aeabi_dsub>
    2726:	4606      	mov	r6, r0
    2728:	460f      	mov	r7, r1
	while (output->precision-->0) {
    272a:	7aa3      	ldrb	r3, [r4, #10]
    272c:	1e5a      	subs	r2, r3, #1
    272e:	72a2      	strb	r2, [r4, #10]
		x = x*10.0;
    2730:	2200      	movs	r2, #0
	if (output->precision<=0) return;
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
    2732:	b18b      	cbz	r3, 2758 <print_float+0x88>
		x = x*10.0;
    2734:	4b11      	ldr	r3, [pc, #68]	; (277c <print_float+0xac>)
    2736:	4630      	mov	r0, r6
    2738:	4639      	mov	r1, r7
    273a:	f7fd ff97 	bl	66c <__aeabi_dmul>
		if (x<1.0) print_putchar(output, '0');
    273e:	2200      	movs	r2, #0
    2740:	4b0f      	ldr	r3, [pc, #60]	; (2780 <print_float+0xb0>)
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
    2742:	4606      	mov	r6, r0
    2744:	460f      	mov	r7, r1
		if (x<1.0) print_putchar(output, '0');
    2746:	f7fe fa03 	bl	b50 <__aeabi_dcmplt>
    274a:	2800      	cmp	r0, #0
    274c:	d0ed      	beq.n	272a <print_float+0x5a>
    274e:	2130      	movs	r1, #48	; 0x30
    2750:	4620      	mov	r0, r4
    2752:	f7ff ff23 	bl	259c <print_putchar>
    2756:	e7e8      	b.n	272a <print_float+0x5a>
	}
	if (x>1) print_long(output, (long)x);
    2758:	4b09      	ldr	r3, [pc, #36]	; (2780 <print_float+0xb0>)
    275a:	4630      	mov	r0, r6
    275c:	4639      	mov	r1, r7
    275e:	f7fe fa15 	bl	b8c <__aeabi_dcmpgt>
    2762:	b148      	cbz	r0, 2778 <print_float+0xa8>
    2764:	4639      	mov	r1, r7
    2766:	4630      	mov	r0, r6
    2768:	f7fe fa1a 	bl	ba0 <__aeabi_d2iz>
    276c:	4601      	mov	r1, r0
    276e:	4620      	mov	r0, r4
}
    2770:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
		if (x<1.0) print_putchar(output, '0');
	}
	if (x>1) print_long(output, (long)x);
    2774:	f7ff bf85 	b.w	2682 <print_long>
    2778:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    277a:	bf00      	nop
    277c:	40240000 	.word	0x40240000
    2780:	3ff00000 	.word	0x3ff00000

Disassembly of section .text.rprintf_RegisterDev:

00002784 <rprintf_RegisterDev>:

#if !defined(LINUX)
// Registra a função de saída do determinado dispositivo para usarmos o rprintf
void rprintf_RegisterDev(const u8 device, int(*putc)(n16) ) {
   	// regitrar a função de saida do dispositivo
   	switch(device) {
    2784:	3804      	subs	r0, #4
    2786:	2803      	cmp	r0, #3
    2788:	d80b      	bhi.n	27a2 <rprintf_RegisterDev+0x1e>
    278a:	e8df f000 	tbb	[pc, r0]
    278e:	0402      	.short	0x0402
    2790:	0806      	.short	0x0806
	case STDIO_DEV1: 	dev1_putc = putc; break;
    2792:	4b04      	ldr	r3, [pc, #16]	; (27a4 <rprintf_RegisterDev+0x20>)
    2794:	e004      	b.n	27a0 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV2: 	dev2_putc = putc; break;
    2796:	4b04      	ldr	r3, [pc, #16]	; (27a8 <rprintf_RegisterDev+0x24>)
    2798:	e002      	b.n	27a0 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV3: 	dev3_putc = putc; break;
    279a:	4b04      	ldr	r3, [pc, #16]	; (27ac <rprintf_RegisterDev+0x28>)
    279c:	e000      	b.n	27a0 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV4: 	dev4_putc = putc; break;
    279e:	4b04      	ldr	r3, [pc, #16]	; (27b0 <rprintf_RegisterDev+0x2c>)
    27a0:	6019      	str	r1, [r3, #0]
    27a2:	4770      	bx	lr
    27a4:	100007d0 	.word	0x100007d0
    27a8:	100007d4 	.word	0x100007d4
    27ac:	100007e0 	.word	0x100007e0
    27b0:	100007dc 	.word	0x100007dc

Disassembly of section .text.lputchar_RegisterDev:

000027b4 <lputchar_RegisterDev>:
}
#endif // #if !defined(LINUX)

// Registra a função de saída padrão
void lputchar_RegisterDev(int (*func_putc)(n16)) {
	stdio_putc = func_putc;
    27b4:	4b01      	ldr	r3, [pc, #4]	; (27bc <lputchar_RegisterDev+0x8>)
    27b6:	6018      	str	r0, [r3, #0]
    27b8:	4770      	bx	lr
    27ba:	bf00      	nop
    27bc:	100007d8 	.word	0x100007d8

Disassembly of section .text.ldebug_RegisterDev:

000027c0 <ldebug_RegisterDev>:
}

// Registra a função de saída padrão de LOG
void ldebug_RegisterDev(int (*putc)(n16)) {
	debug_putc = putc;
    27c0:	4b01      	ldr	r3, [pc, #4]	; (27c8 <ldebug_RegisterDev+0x8>)
    27c2:	6018      	str	r0, [r3, #0]
    27c4:	4770      	bx	lr
    27c6:	bf00      	nop
    27c8:	100007ec 	.word	0x100007ec

Disassembly of section .text.lgetchar_RegisterDev:

000027cc <lgetchar_RegisterDev>:
#endif // #if defined(FREE_RTOS)


// Registra a função de entrada padrão
void lgetchar_RegisterDev(int (*func_getc)(u8*)) {
	stdio_getc = func_getc;
    27cc:	4b01      	ldr	r3, [pc, #4]	; (27d4 <lgetchar_RegisterDev+0x8>)
    27ce:	6018      	str	r0, [r3, #0]
    27d0:	4770      	bx	lr
    27d2:	bf00      	nop
    27d4:	100007e8 	.word	0x100007e8

Disassembly of section .text.doprint:

000027d8 <doprint>:
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    27d8:	e92d 43f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, lr}
    27dc:	4604      	mov	r4, r0
    27de:	4615      	mov	r5, r2
    27e0:	4688      	mov	r8, r1
	char c, doformat = 0;

	output->count = 0;
    27e2:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    27e4:	b095      	sub	sp, #84	; 0x54
	char c, doformat = 0;

	output->count = 0;
    27e6:	6041      	str	r1, [r0, #4]

	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;
    27e8:	f108 0701 	add.w	r7, r8, #1
    27ec:	f898 6000 	ldrb.w	r6, [r8]

		if (doformat) {
    27f0:	2900      	cmp	r1, #0
    27f2:	f000 818b 	beq.w	2b0c <doprint+0x334>
			doformat = 0;

			if ( ((c=='l')||(c=='L')) &&(*fmt=='d')) {
    27f6:	f006 03df 	and.w	r3, r6, #223	; 0xdf
    27fa:	2b4c      	cmp	r3, #76	; 0x4c
    27fc:	d10b      	bne.n	2816 <doprint+0x3e>
    27fe:	f898 3001 	ldrb.w	r3, [r8, #1]
    2802:	2b64      	cmp	r3, #100	; 0x64
    2804:	d107      	bne.n	2816 <doprint+0x3e>
				print_long(output, va_arg(args,long));
    2806:	6829      	ldr	r1, [r5, #0]
    2808:	4620      	mov	r0, r4
    280a:	1d2e      	adds	r6, r5, #4
    280c:	f7ff ff39 	bl	2682 <print_long>
				fmt++;
    2810:	f108 0702 	add.w	r7, r8, #2
    2814:	e0bd      	b.n	2992 <doprint+0x1ba>
				continue;
			}

			switch (c) {
    2816:	2e63      	cmp	r6, #99	; 0x63
    2818:	d03c      	beq.n	2894 <doprint+0xbc>
    281a:	d819      	bhi.n	2850 <doprint+0x78>
    281c:	2e53      	cmp	r6, #83	; 0x53
    281e:	f000 808c 	beq.w	293a <doprint+0x162>
    2822:	d80c      	bhi.n	283e <doprint+0x66>
    2824:	2e43      	cmp	r6, #67	; 0x43
    2826:	d035      	beq.n	2894 <doprint+0xbc>
    2828:	2e44      	cmp	r6, #68	; 0x44
    282a:	d036      	beq.n	289a <doprint+0xc2>
    282c:	2e25      	cmp	r6, #37	; 0x25
    282e:	f040 814f 	bne.w	2ad0 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
    2832:	4631      	mov	r1, r6
    2834:	4620      	mov	r0, r4
    2836:	f7ff feb1 	bl	259c <print_putchar>
    283a:	462e      	mov	r6, r5
    283c:	e17b      	b.n	2b36 <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    283e:	2e58      	cmp	r6, #88	; 0x58
    2840:	d04f      	beq.n	28e2 <doprint+0x10a>
    2842:	2e62      	cmp	r6, #98	; 0x62
    2844:	f000 80d4 	beq.w	29f0 <doprint+0x218>
    2848:	2e55      	cmp	r6, #85	; 0x55
    284a:	f040 8141 	bne.w	2ad0 <doprint+0x2f8>
    284e:	e027      	b.n	28a0 <doprint+0xc8>
    2850:	2e6b      	cmp	r6, #107	; 0x6b
    2852:	f000 8088 	beq.w	2966 <doprint+0x18e>
    2856:	d811      	bhi.n	287c <doprint+0xa4>
    2858:	2e65      	cmp	r6, #101	; 0x65
    285a:	f000 80e8 	beq.w	2a2e <doprint+0x256>
    285e:	d31c      	bcc.n	289a <doprint+0xc2>
    2860:	2e66      	cmp	r6, #102	; 0x66
    2862:	f040 8135 	bne.w	2ad0 <doprint+0x2f8>
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
    2866:	3507      	adds	r5, #7
    2868:	f025 0507 	bic.w	r5, r5, #7
    286c:	e9d5 2300 	ldrd	r2, r3, [r5]
    2870:	4620      	mov	r0, r4
    2872:	f105 0608 	add.w	r6, r5, #8
    2876:	f7ff ff2b 	bl	26d0 <print_float>
    287a:	e15c      	b.n	2b36 <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    287c:	2e74      	cmp	r6, #116	; 0x74
    287e:	f000 8094 	beq.w	29aa <doprint+0x1d2>
    2882:	d802      	bhi.n	288a <doprint+0xb2>
    2884:	2e73      	cmp	r6, #115	; 0x73
    2886:	d058      	beq.n	293a <doprint+0x162>
    2888:	e122      	b.n	2ad0 <doprint+0x2f8>
    288a:	2e75      	cmp	r6, #117	; 0x75
    288c:	d008      	beq.n	28a0 <doprint+0xc8>
    288e:	2e78      	cmp	r6, #120	; 0x78
    2890:	d027      	beq.n	28e2 <doprint+0x10a>
    2892:	e11d      	b.n	2ad0 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
			case 'C' :
			case 'c' : print_putchar(output, va_arg(args,int)); break;
    2894:	1d2e      	adds	r6, r5, #4
    2896:	7829      	ldrb	r1, [r5, #0]
    2898:	e083      	b.n	29a2 <doprint+0x1ca>
			case 'D' :
			case 'd' : print_int(output, va_arg(args,int)); break;
    289a:	1d2e      	adds	r6, r5, #4
    289c:	6829      	ldr	r1, [r5, #0]
    289e:	e113      	b.n	2ac8 <doprint+0x2f0>
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
    28a0:	1d2e      	adds	r6, r5, #4
    28a2:	682b      	ldr	r3, [r5, #0]
	unsigned int d; //digitos
	string digits;

	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    28a4:	f10d 0810 	add.w	r8, sp, #16

static void print_uint(pPrint output, unsigned int x) {
	unsigned int d; //digitos
	string digits;

	d = 0;
    28a8:	2500      	movs	r5, #0
	do	{
		digits[d++] = '0' + x%10;
    28aa:	210a      	movs	r1, #10
    28ac:	fbb3 f2f1 	udiv	r2, r3, r1
    28b0:	fb01 3312 	mls	r3, r1, r2, r3
    28b4:	3501      	adds	r5, #1
    28b6:	3330      	adds	r3, #48	; 0x30
    28b8:	eb08 0005 	add.w	r0, r8, r5
    28bc:	f800 3c01 	strb.w	r3, [r0, #-1]
		x = x/10;
	}while (x);
    28c0:	4613      	mov	r3, r2
    28c2:	2a00      	cmp	r2, #0
    28c4:	d1f2      	bne.n	28ac <doprint+0xd4>

	print_fill(output, d);
    28c6:	4629      	mov	r1, r5
    28c8:	4620      	mov	r0, r4
    28ca:	f7ff fea1 	bl	2610 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    28ce:	f115 35ff 	adds.w	r5, r5, #4294967295
    28d2:	f0c0 8130 	bcc.w	2b36 <doprint+0x35e>
    28d6:	f818 1005 	ldrb.w	r1, [r8, r5]
    28da:	4620      	mov	r0, r4
    28dc:	f7ff fe5e 	bl	259c <print_putchar>
    28e0:	e7f5      	b.n	28ce <doprint+0xf6>
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    28e2:	46ee      	mov	lr, sp
    28e4:	4b97      	ldr	r3, [pc, #604]	; (2b44 <doprint+0x36c>)
			case 'd' : print_int(output, va_arg(args,int)); break;
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
    28e6:	682a      	ldr	r2, [r5, #0]
    28e8:	1d2e      	adds	r6, r5, #4
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    28ea:	f103 0c10 	add.w	ip, r3, #16
    28ee:	4675      	mov	r5, lr
    28f0:	6818      	ldr	r0, [r3, #0]
    28f2:	6859      	ldr	r1, [r3, #4]
    28f4:	3308      	adds	r3, #8
    28f6:	c503      	stmia	r5!, {r0, r1}
    28f8:	4563      	cmp	r3, ip
    28fa:	46ae      	mov	lr, r5
    28fc:	d1f7      	bne.n	28ee <doprint+0x116>
		'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
	};
	char digits[16];

	int d = 0;
    28fe:	2500      	movs	r5, #0
	do	{
		digits[d++] = HexTable[x&0xF];
    2900:	f10d 0810 	add.w	r8, sp, #16
    2904:	f002 030f 	and.w	r3, r2, #15
    2908:	a814      	add	r0, sp, #80	; 0x50
    290a:	4403      	add	r3, r0
    290c:	3501      	adds	r5, #1
    290e:	f813 3c50 	ldrb.w	r3, [r3, #-80]
    2912:	eb08 0105 	add.w	r1, r8, r5
		x = x>>4;
	}while (x);
    2916:	0912      	lsrs	r2, r2, #4
	};
	char digits[16];

	int d = 0;
	do	{
		digits[d++] = HexTable[x&0xF];
    2918:	f801 3c01 	strb.w	r3, [r1, #-1]
		x = x>>4;
	}while (x);
    291c:	d1f2      	bne.n	2904 <doprint+0x12c>

	//print_putchar(output, '0');
	//print_putchar(output, 'x');
	print_fill(output, d);
    291e:	4629      	mov	r1, r5
    2920:	4620      	mov	r0, r4
    2922:	f7ff fe75 	bl	2610 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2926:	f115 35ff 	adds.w	r5, r5, #4294967295
    292a:	f0c0 8104 	bcc.w	2b36 <doprint+0x35e>
    292e:	f818 1005 	ldrb.w	r1, [r8, r5]
    2932:	4620      	mov	r0, r4
    2934:	f7ff fe32 	bl	259c <print_putchar>
    2938:	e7f5      	b.n	2926 <doprint+0x14e>
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
    293a:	1d2e      	adds	r6, r5, #4
    293c:	682d      	ldr	r5, [r5, #0]
	while (n-->0) print_putchar(output, output->fill);
}

static void print_string(pPrint output, char * s) {
	int d = 0;
	if (s==NULL) return;
    293e:	2d00      	cmp	r5, #0
    2940:	f000 80f9 	beq.w	2b36 <doprint+0x35e>
    2944:	46a9      	mov	r9, r5
    2946:	ebc5 0109 	rsb	r1, r5, r9
	while (s[d])
    294a:	f819 8b01 	ldrb.w	r8, [r9], #1
    294e:	f1b8 0f00 	cmp.w	r8, #0
    2952:	d004      	beq.n	295e <doprint+0x186>
		print_putchar(output, s[d++]);
    2954:	4641      	mov	r1, r8
    2956:	4620      	mov	r0, r4
    2958:	f7ff fe20 	bl	259c <print_putchar>
    295c:	e7f3      	b.n	2946 <doprint+0x16e>
	print_fill(output, d);
    295e:	4620      	mov	r0, r4
    2960:	f7ff fe56 	bl	2610 <print_fill>
    2964:	e0e7      	b.n	2b36 <doprint+0x35e>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    2966:	1d2e      	adds	r6, r5, #4
    2968:	6829      	ldr	r1, [r5, #0]
	while (d--) print_putchar(output, digits[d]);
}

#if ( STDIO_USE_SUBINT == pdON )
static void print_intF(pPrint output, long x) {
	int b = 0;
    296a:	2500      	movs	r5, #0
	while (x>10240) { x = x/1024; b++; }
    296c:	f5b1 5f20 	cmp.w	r1, #10240	; 0x2800
    2970:	dd02      	ble.n	2978 <doprint+0x1a0>
    2972:	1289      	asrs	r1, r1, #10
    2974:	3501      	adds	r5, #1
    2976:	e7f9      	b.n	296c <doprint+0x194>
	print_int(output, x);
    2978:	4620      	mov	r0, r4
    297a:	f7ff fe56 	bl	262a <print_int>
	if (b==1) print_putchar(output, 'k');
    297e:	2d01      	cmp	r5, #1
    2980:	d101      	bne.n	2986 <doprint+0x1ae>
    2982:	216b      	movs	r1, #107	; 0x6b
    2984:	e00d      	b.n	29a2 <doprint+0x1ca>
	if (b==2) print_putchar(output, 'M');
    2986:	2d02      	cmp	r5, #2
    2988:	d107      	bne.n	299a <doprint+0x1c2>
    298a:	214d      	movs	r1, #77	; 0x4d
    298c:	4620      	mov	r0, r4
    298e:	f7ff fe05 	bl	259c <print_putchar>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    2992:	4635      	mov	r5, r6
    2994:	2100      	movs	r1, #0
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    2996:	46b8      	mov	r8, r7
    2998:	e726      	b.n	27e8 <doprint+0x10>
	int b = 0;
	while (x>10240) { x = x/1024; b++; }
	print_int(output, x);
	if (b==1) print_putchar(output, 'k');
	if (b==2) print_putchar(output, 'M');
	if (b==3) print_putchar(output, 'G');
    299a:	2d03      	cmp	r5, #3
    299c:	f040 80cb 	bne.w	2b36 <doprint+0x35e>
    29a0:	2147      	movs	r1, #71	; 0x47
    29a2:	4620      	mov	r0, r4
    29a4:	f7ff fdfa 	bl	259c <print_putchar>
    29a8:	e0c5      	b.n	2b36 <doprint+0x35e>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    29aa:	f8d5 9000 	ldr.w	r9, [r5]
	s = x%60;	x = x/60;
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
    29ae:	2302      	movs	r3, #2
    29b0:	7223      	strb	r3, [r4, #8]
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    29b2:	f44f 6161 	mov.w	r1, #3600	; 0xe10
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
    29b6:	2330      	movs	r3, #48	; 0x30
    29b8:	7263      	strb	r3, [r4, #9]
	print_int(output, h);	print_putchar(output, ':');
    29ba:	fb99 f1f1 	sdiv	r1, r9, r1
    29be:	4620      	mov	r0, r4
    29c0:	f7ff fe33 	bl	262a <print_int>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    29c4:	1d2e      	adds	r6, r5, #4
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    29c6:	213a      	movs	r1, #58	; 0x3a
	print_int(output, m);	print_putchar(output, 39);
    29c8:	253c      	movs	r5, #60	; 0x3c
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    29ca:	4620      	mov	r0, r4
    29cc:	f7ff fde6 	bl	259c <print_putchar>
	print_int(output, m);	print_putchar(output, 39);
    29d0:	fb99 f8f5 	sdiv	r8, r9, r5
    29d4:	fb98 f1f5 	sdiv	r1, r8, r5
    29d8:	4620      	mov	r0, r4
    29da:	fb05 8111 	mls	r1, r5, r1, r8
    29de:	f7ff fe24 	bl	262a <print_int>
    29e2:	2127      	movs	r1, #39	; 0x27
    29e4:	4620      	mov	r0, r4
    29e6:	f7ff fdd9 	bl	259c <print_putchar>
	print_int(output, s);
    29ea:	fb05 9118 	mls	r1, r5, r8, r9
    29ee:	e06b      	b.n	2ac8 <doprint+0x2f0>

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    29f0:	2230      	movs	r2, #48	; 0x30
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
    29f2:	682b      	ldr	r3, [r5, #0]
    29f4:	1d2e      	adds	r6, r5, #4

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    29f6:	7262      	strb	r2, [r4, #9]
#endif

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
    29f8:	2500      	movs	r5, #0
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    29fa:	f10d 0810 	add.w	r8, sp, #16
    29fe:	f003 0201 	and.w	r2, r3, #1
    2a02:	3501      	adds	r5, #1
    2a04:	eb08 0105 	add.w	r1, r8, r5
    2a08:	3230      	adds	r2, #48	; 0x30
		x = x>>1;
	}while (x);
    2a0a:	105b      	asrs	r3, r3, #1
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    2a0c:	f801 2c01 	strb.w	r2, [r1, #-1]
		x = x>>1;
	}while (x);
    2a10:	d1f5      	bne.n	29fe <doprint+0x226>
	//print_putchar(output, '0');
	//print_putchar(output, 'b');
	print_fill(output, d);
    2a12:	4629      	mov	r1, r5
    2a14:	4620      	mov	r0, r4
    2a16:	f7ff fdfb 	bl	2610 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    2a1a:	f115 35ff 	adds.w	r5, r5, #4294967295
    2a1e:	f0c0 808a 	bcc.w	2b36 <doprint+0x35e>
    2a22:	f818 1005 	ldrb.w	r1, [r8, r5]
    2a26:	4620      	mov	r0, r4
    2a28:	f7ff fdb8 	bl	259c <print_putchar>
    2a2c:	e7f5      	b.n	2a1a <doprint+0x242>
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
    2a2e:	3507      	adds	r5, #7
    2a30:	f025 0507 	bic.w	r5, r5, #7
    2a34:	f8d5 8000 	ldr.w	r8, [r5]
    2a38:	f105 0608 	add.w	r6, r5, #8
    2a3c:	686d      	ldr	r5, [r5, #4]
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
	if (x<0) { print_putchar(output, '-'); x = -x; }
    2a3e:	2200      	movs	r2, #0
    2a40:	2300      	movs	r3, #0
    2a42:	4640      	mov	r0, r8
    2a44:	4629      	mov	r1, r5
    2a46:	f7fe f883 	bl	b50 <__aeabi_dcmplt>
    2a4a:	b128      	cbz	r0, 2a58 <doprint+0x280>
    2a4c:	212d      	movs	r1, #45	; 0x2d
    2a4e:	4620      	mov	r0, r4
    2a50:	f7ff fda4 	bl	259c <print_putchar>
    2a54:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	if (x!=0) {
    2a58:	2200      	movs	r2, #0
    2a5a:	2300      	movs	r3, #0
    2a5c:	4640      	mov	r0, r8
    2a5e:	4629      	mov	r1, r5
    2a60:	f7fe f86c 	bl	b3c <__aeabi_dcmpeq>
    2a64:	bb20      	cbnz	r0, 2ab0 <doprint+0x2d8>
    2a66:	4681      	mov	r9, r0
		while (x<1) { x = x*10; exp--; }
    2a68:	2200      	movs	r2, #0
    2a6a:	4b37      	ldr	r3, [pc, #220]	; (2b48 <doprint+0x370>)
    2a6c:	4640      	mov	r0, r8
    2a6e:	4629      	mov	r1, r5
    2a70:	f7fe f86e 	bl	b50 <__aeabi_dcmplt>
    2a74:	b150      	cbz	r0, 2a8c <doprint+0x2b4>
    2a76:	4640      	mov	r0, r8
    2a78:	4629      	mov	r1, r5
    2a7a:	2200      	movs	r2, #0
    2a7c:	4b33      	ldr	r3, [pc, #204]	; (2b4c <doprint+0x374>)
    2a7e:	f7fd fdf5 	bl	66c <__aeabi_dmul>
    2a82:	f109 39ff 	add.w	r9, r9, #4294967295
    2a86:	4680      	mov	r8, r0
    2a88:	460d      	mov	r5, r1
    2a8a:	e7ed      	b.n	2a68 <doprint+0x290>
		while (x>10){ x = x/10; exp++; }
    2a8c:	2200      	movs	r2, #0
    2a8e:	4b2f      	ldr	r3, [pc, #188]	; (2b4c <doprint+0x374>)
    2a90:	4640      	mov	r0, r8
    2a92:	4629      	mov	r1, r5
    2a94:	f7fe f87a 	bl	b8c <__aeabi_dcmpgt>
    2a98:	b160      	cbz	r0, 2ab4 <doprint+0x2dc>
    2a9a:	4640      	mov	r0, r8
    2a9c:	4629      	mov	r1, r5
    2a9e:	2200      	movs	r2, #0
    2aa0:	4b2a      	ldr	r3, [pc, #168]	; (2b4c <doprint+0x374>)
    2aa2:	f7fd ff0d 	bl	8c0 <__aeabi_ddiv>
    2aa6:	f109 0901 	add.w	r9, r9, #1
    2aaa:	4680      	mov	r8, r0
    2aac:	460d      	mov	r5, r1
    2aae:	e7ed      	b.n	2a8c <doprint+0x2b4>
	}
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
    2ab0:	f04f 0900 	mov.w	r9, #0
	if (x<0) { print_putchar(output, '-'); x = -x; }
	if (x!=0) {
		while (x<1) { x = x*10; exp--; }
		while (x>10){ x = x/10; exp++; }
	}
	print_float(output, x);
    2ab4:	4642      	mov	r2, r8
    2ab6:	462b      	mov	r3, r5
    2ab8:	4620      	mov	r0, r4
    2aba:	f7ff fe09 	bl	26d0 <print_float>
	print_putchar(output, 'E');
    2abe:	2145      	movs	r1, #69	; 0x45
    2ac0:	4620      	mov	r0, r4
    2ac2:	f7ff fd6b 	bl	259c <print_putchar>
	print_int(output, exp);
    2ac6:	4649      	mov	r1, r9
    2ac8:	4620      	mov	r0, r4
    2aca:	f7ff fdae 	bl	262a <print_int>
    2ace:	e032      	b.n	2b36 <doprint+0x35e>
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
			#endif
			default :
				// preencher com '0'?
				if ( (c=='0')&&(output->prefix==0) ) {
    2ad0:	2e30      	cmp	r6, #48	; 0x30
    2ad2:	d103      	bne.n	2adc <doprint+0x304>
    2ad4:	7a23      	ldrb	r3, [r4, #8]
    2ad6:	b953      	cbnz	r3, 2aee <doprint+0x316>
					doformat = 1; output->fill = '0';
    2ad8:	7266      	strb	r6, [r4, #9]
    2ada:	e01e      	b.n	2b1a <doprint+0x342>
					continue;
				}

				// vai indicar a precisao
				if (c=='.') {
    2adc:	2e2e      	cmp	r6, #46	; 0x2e
    2ade:	d106      	bne.n	2aee <doprint+0x316>
					doformat = 1;
					output->precision = (*fmt++)-'0';
    2ae0:	f898 3001 	ldrb.w	r3, [r8, #1]
    2ae4:	f108 0702 	add.w	r7, r8, #2
    2ae8:	3b30      	subs	r3, #48	; 0x30
    2aea:	72a3      	strb	r3, [r4, #10]
    2aec:	e015      	b.n	2b1a <doprint+0x342>
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
    2aee:	f1a6 0330 	sub.w	r3, r6, #48	; 0x30
    2af2:	2b09      	cmp	r3, #9
    2af4:	d808      	bhi.n	2b08 <doprint+0x330>
					doformat = 1;
					output->prefix = output->prefix*10 + (c - '0');
    2af6:	7a23      	ldrb	r3, [r4, #8]
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
					doformat = 1;
    2af8:	2101      	movs	r1, #1
					output->prefix = output->prefix*10 + (c - '0');
    2afa:	eb03 0383 	add.w	r3, r3, r3, lsl #2
    2afe:	eb06 0643 	add.w	r6, r6, r3, lsl #1
    2b02:	3e30      	subs	r6, #48	; 0x30
    2b04:	7226      	strb	r6, [r4, #8]
					continue;
    2b06:	e746      	b.n	2996 <doprint+0x1be>
				}
				print_putchar(output, '?');
    2b08:	213f      	movs	r1, #63	; 0x3f
    2b0a:	e00d      	b.n	2b28 <doprint+0x350>
				break;
			}
			continue;
		}

		if (c=='%')	{
    2b0c:	2e25      	cmp	r6, #37	; 0x25
    2b0e:	d107      	bne.n	2b20 <doprint+0x348>
			doformat = 1;
			output->prefix = 0;
			output->precision = 5;
    2b10:	2305      	movs	r3, #5
    2b12:	72a3      	strb	r3, [r4, #10]
			output->fill = ' ';
    2b14:	2320      	movs	r3, #32
			continue;
		}

		if (c=='%')	{
			doformat = 1;
			output->prefix = 0;
    2b16:	7221      	strb	r1, [r4, #8]
			output->precision = 5;
			output->fill = ' ';
    2b18:	7263      	strb	r3, [r4, #9]
			continue;
    2b1a:	462e      	mov	r6, r5
			}
			continue;
		}

		if (c=='%')	{
			doformat = 1;
    2b1c:	2101      	movs	r1, #1
			output->prefix = 0;
			output->precision = 5;
			output->fill = ' ';
			continue;
    2b1e:	e00b      	b.n	2b38 <doprint+0x360>
		}

		// Não imprime o caractere nulo (foi incluso essa cláusula em 27/06/2014)
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
    2b20:	b90e      	cbnz	r6, 2b26 <doprint+0x34e>
    2b22:	7ae3      	ldrb	r3, [r4, #11]
    2b24:	b153      	cbz	r3, 2b3c <doprint+0x364>
			print_putchar(output, c);
    2b26:	4631      	mov	r1, r6
    2b28:	4620      	mov	r0, r4
    2b2a:	f7ff fd37 	bl	259c <print_putchar>
	} while (c);
    2b2e:	2e00      	cmp	r6, #0
    2b30:	f47f af30 	bne.w	2994 <doprint+0x1bc>
    2b34:	e002      	b.n	2b3c <doprint+0x364>
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    2b36:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    2b38:	4635      	mov	r5, r6
    2b3a:	e72c      	b.n	2996 <doprint+0x1be>
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
			print_putchar(output, c);
	} while (c);
}
    2b3c:	b015      	add	sp, #84	; 0x54
    2b3e:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}
    2b42:	bf00      	nop
    2b44:	0000385c 	.word	0x0000385c
    2b48:	3ff00000 	.word	0x3ff00000
    2b4c:	40240000 	.word	0x40240000

Disassembly of section .text.lgetchar:

00002b50 <lgetchar>:

// #######################################################################################################################
// FUNÇÕES DE ENTRADA E DE SAÍDAS DE IMPRESSÃO NOS DISPOSITIVOS
// #######################################################################################################################
int lgetchar(u8 *ch) {
	return stdio_getc(ch);
    2b50:	4b01      	ldr	r3, [pc, #4]	; (2b58 <lgetchar+0x8>)
    2b52:	681b      	ldr	r3, [r3, #0]
    2b54:	4718      	bx	r3
    2b56:	bf00      	nop
    2b58:	100007e8 	.word	0x100007e8

Disassembly of section .text.rprintf:

00002b5c <rprintf>:
//	lprintf("BIN: 0b%b 0b%2b"CMD_TERMINATOR, 0x123, 0x456);
//	lprintf("String: %s"CMD_TERMINATOR, "imprimindo");
#if defined(LINUX)
int rprintf(const char* fmt, ...) {
#else
int rprintf(const u8 device, const cpchar fmt, ...) {
    2b5c:	b40e      	push	{r1, r2, r3}
    2b5e:	b53f      	push	{r0, r1, r2, r3, r4, r5, lr}
    2b60:	aa07      	add	r2, sp, #28
    2b62:	f852 1b04 	ldr.w	r1, [r2], #4
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    2b66:	2300      	movs	r3, #0
	// Travar o recurso de saída para transmissão completa da mensagem, esperar MAX_DELAY caso o recurso está sendo usado
	ret = xSemaphoreTake(mutex, portMAX_DELAY);
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
    2b68:	f88d 0014 	strb.w	r0, [sp, #20]
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
	output.isSformat = 0;			// Sinaliza que não é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    2b6c:	a802      	add	r0, sp, #8
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    2b6e:	9302      	str	r3, [sp, #8]
	output.isSformat = 0;			// Sinaliza que não é um sformat
    2b70:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    2b74:	9201      	str	r2, [sp, #4]
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    2b76:	f7ff fe2f 	bl	27d8 <doprint>
	// Liberar o recuro de saida
	xSemaphoreGive(mutex);
	#endif

  	return ret;
}
    2b7a:	2001      	movs	r0, #1
    2b7c:	b006      	add	sp, #24
    2b7e:	f85d eb04 	ldr.w	lr, [sp], #4
    2b82:	b003      	add	sp, #12
    2b84:	4770      	bx	lr

Disassembly of section .text.buffer_Init:

00002b86 <buffer_Init>:
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
	buffer->size = size;
	// initialize index and length
	buffer->dataindex = 0;
    2b86:	2300      	movs	r3, #0
// Parametros: 	Endereço da estrutura do buffer, endereço do vetor de dados e o tamanho do vetor
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
    2b88:	6001      	str	r1, [r0, #0]
	buffer->size = size;
    2b8a:	8082      	strh	r2, [r0, #4]
	// initialize index and length
	buffer->dataindex = 0;
    2b8c:	8103      	strh	r3, [r0, #8]
	buffer->datalength = 0;
    2b8e:	80c3      	strh	r3, [r0, #6]
    2b90:	4770      	bx	lr

Disassembly of section .text.buffer_GetFromFront:

00002b92 <buffer_GetFromFront>:
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    2b92:	4603      	mov	r3, r0
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    2b94:	88c0      	ldrh	r0, [r0, #6]
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    2b96:	b510      	push	{r4, lr}
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    2b98:	b280      	uxth	r0, r0
    2b9a:	b1d8      	cbz	r0, 2bd4 <buffer_GetFromFront+0x42>
		// get the first character from buffer
		data = buffer->dataptr[buffer->dataindex];
    2b9c:	6819      	ldr	r1, [r3, #0]
    2b9e:	891a      	ldrh	r2, [r3, #8]
    2ba0:	b292      	uxth	r2, r2
    2ba2:	5c88      	ldrb	r0, [r1, r2]
		// move index down and decrement length
		buffer->dataindex++;
    2ba4:	891a      	ldrh	r2, [r3, #8]
    2ba6:	3201      	adds	r2, #1
    2ba8:	b292      	uxth	r2, r2
    2baa:	811a      	strh	r2, [r3, #8]
		if(buffer->dataindex >= buffer->size) {
    2bac:	8919      	ldrh	r1, [r3, #8]
    2bae:	889a      	ldrh	r2, [r3, #4]
    2bb0:	b289      	uxth	r1, r1
    2bb2:	b292      	uxth	r2, r2
    2bb4:	4291      	cmp	r1, r2
    2bb6:	d309      	bcc.n	2bcc <buffer_GetFromFront+0x3a>
			buffer->dataindex %= buffer->size;
    2bb8:	889a      	ldrh	r2, [r3, #4]
    2bba:	b294      	uxth	r4, r2
    2bbc:	891a      	ldrh	r2, [r3, #8]
    2bbe:	b292      	uxth	r2, r2
    2bc0:	fbb2 f1f4 	udiv	r1, r2, r4
    2bc4:	fb04 2211 	mls	r2, r4, r1, r2
    2bc8:	b292      	uxth	r2, r2
    2bca:	811a      	strh	r2, [r3, #8]
		}
		buffer->datalength--;
    2bcc:	88da      	ldrh	r2, [r3, #6]
    2bce:	3a01      	subs	r2, #1
    2bd0:	b292      	uxth	r2, r2
    2bd2:	80da      	strh	r2, [r3, #6]
	}
	
	return data;
}
    2bd4:	bd10      	pop	{r4, pc}

Disassembly of section .text.buffer_AddToEnd:

00002bd6 <buffer_AddToEnd>:
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    2bd6:	88c2      	ldrh	r2, [r0, #6]
    2bd8:	8883      	ldrh	r3, [r0, #4]
    2bda:	b292      	uxth	r2, r2
    2bdc:	b29b      	uxth	r3, r3
    2bde:	429a      	cmp	r2, r3
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Adiciona o caractere no fim do buffer
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
    2be0:	b530      	push	{r4, r5, lr}
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    2be2:	d212      	bcs.n	2c0a <buffer_AddToEnd+0x34>
		// save data byte at end of buffer
		buffer->dataptr[(buffer->dataindex + buffer->datalength) % buffer->size] = data;
    2be4:	6805      	ldr	r5, [r0, #0]
    2be6:	8903      	ldrh	r3, [r0, #8]
    2be8:	88c2      	ldrh	r2, [r0, #6]
    2bea:	8884      	ldrh	r4, [r0, #4]
    2bec:	b292      	uxth	r2, r2
    2bee:	b29b      	uxth	r3, r3
    2bf0:	b2a4      	uxth	r4, r4
    2bf2:	4413      	add	r3, r2
    2bf4:	fb93 f2f4 	sdiv	r2, r3, r4
    2bf8:	fb04 3312 	mls	r3, r4, r2, r3
    2bfc:	54e9      	strb	r1, [r5, r3]
		// increment the length
		buffer->datalength++;
    2bfe:	88c3      	ldrh	r3, [r0, #6]
    2c00:	3301      	adds	r3, #1
    2c02:	b29b      	uxth	r3, r3
    2c04:	80c3      	strh	r3, [r0, #6]
		// return success
		return pdPASS;
    2c06:	2001      	movs	r0, #1
    2c08:	bd30      	pop	{r4, r5, pc}
	} else 
		return errBUFFER_FULL;
    2c0a:	f06f 0009 	mvn.w	r0, #9
}
    2c0e:	bd30      	pop	{r4, r5, pc}

Disassembly of section .text.buffer_IsEmpty:

00002c10 <buffer_IsEmpty>:
// Descrição: 	Verifica se o buffer esta vazio
// Parametros: 	Ponteiro para estrutura do buffer
// Retorna: 	Retorna pdTRUE se o buffer está vazio
//------------------------------------------------------------------------------------------------------------------
int buffer_IsEmpty(buffer_t *buffer) {
	if (buffer->datalength == 0)
    2c10:	88c0      	ldrh	r0, [r0, #6]
    2c12:	b280      	uxth	r0, r0
		return pdTRUE;
	else
		return pdFALSE;
}
    2c14:	fab0 f080 	clz	r0, r0
    2c18:	0940      	lsrs	r0, r0, #5
    2c1a:	4770      	bx	lr

Disassembly of section .text.put_dump16:

00002c1c <put_dump16>:
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    2c1c:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    2c1e:	4606      	mov	r6, r0
    2c20:	4615      	mov	r5, r2

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    2c22:	2001      	movs	r0, #1
    2c24:	460a      	mov	r2, r1
    2c26:	491b      	ldr	r1, [pc, #108]	; (2c94 <put_dump16+0x78>)
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    2c28:	461f      	mov	r7, r3

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    2c2a:	f7ff ff97 	bl	2b5c <rprintf>
	#endif
	
	// IMPRIME HEXDECIMAL
	for(n=0; n<cnt; n++) lprintf(" %02x", buff[n]);
    2c2e:	2300      	movs	r3, #0
    2c30:	1c5c      	adds	r4, r3, #1
    2c32:	b2db      	uxtb	r3, r3
    2c34:	42ab      	cmp	r3, r5
    2c36:	da06      	bge.n	2c46 <put_dump16+0x2a>
    2c38:	5cf2      	ldrb	r2, [r6, r3]
    2c3a:	4917      	ldr	r1, [pc, #92]	; (2c98 <put_dump16+0x7c>)
    2c3c:	2001      	movs	r0, #1
    2c3e:	f7ff ff8d 	bl	2b5c <rprintf>
    2c42:	4623      	mov	r3, r4
    2c44:	e7f4      	b.n	2c30 <put_dump16+0x14>
		
	// CASO A QUANTIDADE DE BYTES DA LINHA NÃO SEJA O TAMANHO DA MASK
	// Isto preenche a coluna hex com espaços para que a coluna dos caracteres se alinhe com as impressões anteriores
	for(n=cnt; n<mask; n++)	lprintf("   ");
    2c46:	b2ec      	uxtb	r4, r5
    2c48:	42bc      	cmp	r4, r7
    2c4a:	d206      	bcs.n	2c5a <put_dump16+0x3e>
    2c4c:	4913      	ldr	r1, [pc, #76]	; (2c9c <put_dump16+0x80>)
    2c4e:	2001      	movs	r0, #1
    2c50:	3401      	adds	r4, #1
    2c52:	f7ff ff83 	bl	2b5c <rprintf>
    2c56:	b2e4      	uxtb	r4, r4
    2c58:	e7f6      	b.n	2c48 <put_dump16+0x2c>
	
	// IMPRIME SEPARADOR
	lprintf(" : ");
    2c5a:	4911      	ldr	r1, [pc, #68]	; (2ca0 <put_dump16+0x84>)
    2c5c:	2001      	movs	r0, #1
    2c5e:	f7ff ff7d 	bl	2b5c <rprintf>
	
	// IMPRIME CHAR
	for(n = 0; n < cnt; n++) {
    2c62:	2400      	movs	r4, #0
    2c64:	b2e3      	uxtb	r3, r4
    2c66:	429d      	cmp	r5, r3
    2c68:	dd0d      	ble.n	2c86 <put_dump16+0x6a>
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
    2c6a:	5cf2      	ldrb	r2, [r6, r3]
    2c6c:	2a1f      	cmp	r2, #31
    2c6e:	d804      	bhi.n	2c7a <put_dump16+0x5e>
    2c70:	490c      	ldr	r1, [pc, #48]	; (2ca4 <put_dump16+0x88>)
    2c72:	2001      	movs	r0, #1
    2c74:	f7ff ff72 	bl	2b5c <rprintf>
    2c78:	e003      	b.n	2c82 <put_dump16+0x66>
		else					lprintf("%c", buff[n]);
    2c7a:	490b      	ldr	r1, [pc, #44]	; (2ca8 <put_dump16+0x8c>)
    2c7c:	2001      	movs	r0, #1
    2c7e:	f7ff ff6d 	bl	2b5c <rprintf>
    2c82:	3401      	adds	r4, #1
    2c84:	e7ee      	b.n	2c64 <put_dump16+0x48>
	}
	
	lprintf(CMD_TERMINATOR);
    2c86:	4909      	ldr	r1, [pc, #36]	; (2cac <put_dump16+0x90>)
    2c88:	2001      	movs	r0, #1
}
    2c8a:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
		else					lprintf("%c", buff[n]);
	}
	
	lprintf(CMD_TERMINATOR);
    2c8e:	f7ff bf65 	b.w	2b5c <rprintf>
    2c92:	bf00      	nop
    2c94:	00003f29 	.word	0x00003f29
    2c98:	00003f2f 	.word	0x00003f2f
    2c9c:	00003f35 	.word	0x00003f35
    2ca0:	00003f39 	.word	0x00003f39
    2ca4:	00003f24 	.word	0x00003f24
    2ca8:	00003f26 	.word	0x00003f26
    2cac:	00003c77 	.word	0x00003c77

Disassembly of section .text.xatoi:

00002cb0 <xatoi>:
//				Exemplos: "0x10" ret 16. 	"-100" ret -100. 	"0b1100" ret 12
// Parametros: 	Endereço da string para ser convertida e o endereço da var inteira par retorno da conversão
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
    2cb0:	b570      	push	{r4, r5, r6, lr}
	u32 val;
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
    2cb2:	6802      	ldr	r2, [r0, #0]
    2cb4:	7813      	ldrb	r3, [r2, #0]
    2cb6:	2b20      	cmp	r3, #32
    2cb8:	d102      	bne.n	2cc0 <xatoi+0x10>
    2cba:	3201      	adds	r2, #1
    2cbc:	6002      	str	r2, [r0, #0]
    2cbe:	e7f8      	b.n	2cb2 <xatoi+0x2>
	if (c == '-') {
    2cc0:	2b2d      	cmp	r3, #45	; 0x2d
		s = 1;
		c = *(++(*str));
    2cc2:	bf01      	itttt	eq
    2cc4:	1c53      	addeq	r3, r2, #1
    2cc6:	6003      	streq	r3, [r0, #0]
    2cc8:	7853      	ldrbeq	r3, [r2, #1]
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
	if (c == '-') {
		s = 1;
    2cca:	2601      	moveq	r6, #1
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
	u32 val;
	u8 c, radix, s = 0;
    2ccc:	bf18      	it	ne
    2cce:	2600      	movne	r6, #0
	if (c == '-') {
		s = 1;
		c = *(++(*str));
	}
	
	if (c == '0') {
    2cd0:	2b30      	cmp	r3, #48	; 0x30
    2cd2:	d11c      	bne.n	2d0e <xatoi+0x5e>
		c = *(++(*str));
    2cd4:	6802      	ldr	r2, [r0, #0]
    2cd6:	1c53      	adds	r3, r2, #1
    2cd8:	6003      	str	r3, [r0, #0]
    2cda:	7853      	ldrb	r3, [r2, #1]
		if (c <= ' ') {
    2cdc:	2b20      	cmp	r3, #32
    2cde:	d802      	bhi.n	2ce6 <xatoi+0x36>
			*res = 0; return pdTRUE;
    2ce0:	2300      	movs	r3, #0
    2ce2:	600b      	str	r3, [r1, #0]
    2ce4:	e036      	b.n	2d54 <xatoi+0xa4>
		}
		if (c == 'x') {
    2ce6:	2b78      	cmp	r3, #120	; 0x78
    2ce8:	d104      	bne.n	2cf4 <xatoi+0x44>
			radix = 16;
			c = *(++(*str));
    2cea:	1c93      	adds	r3, r2, #2
    2cec:	6003      	str	r3, [r0, #0]
    2cee:	7893      	ldrb	r3, [r2, #2]
		c = *(++(*str));
		if (c <= ' ') {
			*res = 0; return pdTRUE;
		}
		if (c == 'x') {
			radix = 16;
    2cf0:	2510      	movs	r5, #16
    2cf2:	e013      	b.n	2d1c <xatoi+0x6c>
			c = *(++(*str));
		} else {
			if (c == 'b') {
    2cf4:	2b62      	cmp	r3, #98	; 0x62
    2cf6:	d104      	bne.n	2d02 <xatoi+0x52>
				radix = 2;
				c = *(++(*str));
    2cf8:	1c93      	adds	r3, r2, #2
    2cfa:	6003      	str	r3, [r0, #0]
    2cfc:	7893      	ldrb	r3, [r2, #2]
		if (c == 'x') {
			radix = 16;
			c = *(++(*str));
		} else {
			if (c == 'b') {
				radix = 2;
    2cfe:	2502      	movs	r5, #2
    2d00:	e00c      	b.n	2d1c <xatoi+0x6c>
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
    2d02:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    2d06:	2a09      	cmp	r2, #9
    2d08:	d907      	bls.n	2d1a <xatoi+0x6a>
					radix = 8;
				else
					return pdFALSE;
    2d0a:	2000      	movs	r0, #0
    2d0c:	bd70      	pop	{r4, r5, r6, pc}
			}
		}
	} else {
		if ((c < '1')||(c > '9'))
    2d0e:	f1a3 0231 	sub.w	r2, r3, #49	; 0x31
    2d12:	2a08      	cmp	r2, #8
    2d14:	d8f9      	bhi.n	2d0a <xatoi+0x5a>
			return pdFALSE;
		radix = 10;
    2d16:	250a      	movs	r5, #10
    2d18:	e000      	b.n	2d1c <xatoi+0x6c>
			if (c == 'b') {
				radix = 2;
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
					radix = 8;
    2d1a:	2508      	movs	r5, #8
	} else {
		if ((c < '1')||(c > '9'))
			return pdFALSE;
		radix = 10;
	}
	val = 0;
    2d1c:	2400      	movs	r4, #0
	while (c > ' ') {
    2d1e:	2b20      	cmp	r3, #32
    2d20:	d915      	bls.n	2d4e <xatoi+0x9e>
		if (c >= 'a') c -= 0x20;
    2d22:	2b60      	cmp	r3, #96	; 0x60
    2d24:	bf84      	itt	hi
    2d26:	3b20      	subhi	r3, #32
    2d28:	b2db      	uxtbhi	r3, r3
		c -= '0';
    2d2a:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    2d2e:	b2d2      	uxtb	r2, r2
		if (c >= 17) {
    2d30:	2a10      	cmp	r2, #16
    2d32:	d903      	bls.n	2d3c <xatoi+0x8c>
			c -= 7;
    2d34:	3b37      	subs	r3, #55	; 0x37
    2d36:	b2da      	uxtb	r2, r3
			if (c <= 9) return pdFALSE;
    2d38:	2a09      	cmp	r2, #9
    2d3a:	d9e6      	bls.n	2d0a <xatoi+0x5a>
		}
		if (c >= radix) return pdFALSE;
    2d3c:	42aa      	cmp	r2, r5
    2d3e:	d2e4      	bcs.n	2d0a <xatoi+0x5a>
		val = val * radix + c;
		c = *(++(*str));
    2d40:	6803      	ldr	r3, [r0, #0]
		if (c >= 17) {
			c -= 7;
			if (c <= 9) return pdFALSE;
		}
		if (c >= radix) return pdFALSE;
		val = val * radix + c;
    2d42:	fb04 2405 	mla	r4, r4, r5, r2
		c = *(++(*str));
    2d46:	1c5a      	adds	r2, r3, #1
    2d48:	6002      	str	r2, [r0, #0]
    2d4a:	785b      	ldrb	r3, [r3, #1]
    2d4c:	e7e7      	b.n	2d1e <xatoi+0x6e>
	}
	if (s) val = -val;
    2d4e:	b106      	cbz	r6, 2d52 <xatoi+0xa2>
    2d50:	4264      	negs	r4, r4
	*res = val;
    2d52:	600c      	str	r4, [r1, #0]
	return pdTRUE;
    2d54:	2001      	movs	r0, #1
}
    2d56:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.ledError_Init:

00002d58 <ledError_Init>:
static void led_SetupPorts(void);
static void led_State(int st);

#if defined(CPU_ARM_LPC)
static void led_SetupPorts(void) {
	ledERROR_DIR |= ledERROR;
    2d58:	4a04      	ldr	r2, [pc, #16]	; (2d6c <ledError_Init+0x14>)
    2d5a:	6813      	ldr	r3, [r2, #0]
    2d5c:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    2d60:	6013      	str	r3, [r2, #0]
	ledERROR_OFF |= ledERROR;
    2d62:	69d3      	ldr	r3, [r2, #28]
    2d64:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    2d68:	61d3      	str	r3, [r2, #28]
    2d6a:	4770      	bx	lr
    2d6c:	2009c080 	.word	0x2009c080

Disassembly of section .text.ledError_Tick:

00002d70 <ledError_Tick>:


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
	if (!ledBlink) return;
    2d70:	4b1b      	ldr	r3, [pc, #108]	; (2de0 <ledError_Tick+0x70>)
}


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
    2d72:	b570      	push	{r4, r5, r6, lr}
	if (!ledBlink) return;
    2d74:	681b      	ldr	r3, [r3, #0]
    2d76:	2b00      	cmp	r3, #0
    2d78:	d031      	beq.n	2dde <ledError_Tick+0x6e>
	static int count1 = 0;
	static int count2 = 0;
	static int ff = 0;
	static int nTimes = 0;

	if (count1==0) {
    2d7a:	4a1a      	ldr	r2, [pc, #104]	; (2de4 <ledError_Tick+0x74>)
    2d7c:	6813      	ldr	r3, [r2, #0]
    2d7e:	2b00      	cmp	r3, #0
    2d80:	d12b      	bne.n	2dda <ledError_Tick+0x6a>
		if (count2==0) { // Prepara o intervalo entre as piscadas do led
    2d82:	4b19      	ldr	r3, [pc, #100]	; (2de8 <ledError_Tick+0x78>)
    2d84:	4c19      	ldr	r4, [pc, #100]	; (2dec <ledError_Tick+0x7c>)
    2d86:	6819      	ldr	r1, [r3, #0]
    2d88:	b931      	cbnz	r1, 2d98 <ledError_Tick+0x28>
			count2 = 1000;
    2d8a:	f44f 717a 	mov.w	r1, #1000	; 0x3e8
    2d8e:	6019      	str	r1, [r3, #0]
			nTimes = 2*(error);
    2d90:	4917      	ldr	r1, [pc, #92]	; (2df0 <ledError_Tick+0x80>)
    2d92:	6809      	ldr	r1, [r1, #0]
    2d94:	0049      	lsls	r1, r1, #1
    2d96:	6021      	str	r1, [r4, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
    2d98:	6821      	ldr	r1, [r4, #0]
    2d9a:	2900      	cmp	r1, #0
    2d9c:	dd11      	ble.n	2dc2 <ledError_Tick+0x52>
			if (ff)	led_State(pdOFF); else led_State(pdON);
    2d9e:	4b15      	ldr	r3, [pc, #84]	; (2df4 <ledError_Tick+0x84>)
    2da0:	6818      	ldr	r0, [r3, #0]
    2da2:	b108      	cbz	r0, 2da8 <ledError_Tick+0x38>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    2da4:	4e14      	ldr	r6, [pc, #80]	; (2df8 <ledError_Tick+0x88>)
    2da6:	e000      	b.n	2daa <ledError_Tick+0x3a>
    2da8:	4e14      	ldr	r6, [pc, #80]	; (2dfc <ledError_Tick+0x8c>)
    2daa:	6835      	ldr	r5, [r6, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
    2dac:	f080 0001 	eor.w	r0, r0, #1
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    2db0:	f045 5500 	orr.w	r5, r5, #536870912	; 0x20000000
    2db4:	6035      	str	r5, [r6, #0]

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
			nTimes--;
    2db6:	3901      	subs	r1, #1
			nTimes = 2*(error);
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
    2db8:	25fa      	movs	r5, #250	; 0xfa
    2dba:	6015      	str	r5, [r2, #0]
			ff ^= 1;
    2dbc:	6018      	str	r0, [r3, #0]
			nTimes--;
    2dbe:	6021      	str	r1, [r4, #0]
    2dc0:	e009      	b.n	2dd6 <ledError_Tick+0x66>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    2dc2:	480d      	ldr	r0, [pc, #52]	; (2df8 <ledError_Tick+0x88>)
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    2dc4:	681b      	ldr	r3, [r3, #0]
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    2dc6:	6801      	ldr	r1, [r0, #0]
    2dc8:	f041 5100 	orr.w	r1, r1, #536870912	; 0x20000000
    2dcc:	6001      	str	r1, [r0, #0]
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    2dce:	b133      	cbz	r3, 2dde <ledError_Tick+0x6e>
    2dd0:	4905      	ldr	r1, [pc, #20]	; (2de8 <ledError_Tick+0x78>)
    2dd2:	3b01      	subs	r3, #1
    2dd4:	600b      	str	r3, [r1, #0]
		}
	}

	if (count1) count1--;
    2dd6:	6813      	ldr	r3, [r2, #0]
    2dd8:	b10b      	cbz	r3, 2dde <ledError_Tick+0x6e>
    2dda:	3b01      	subs	r3, #1
    2ddc:	6013      	str	r3, [r2, #0]
    2dde:	bd70      	pop	{r4, r5, r6, pc}
    2de0:	10000804 	.word	0x10000804
    2de4:	10000808 	.word	0x10000808
    2de8:	100007fc 	.word	0x100007fc
    2dec:	100007f4 	.word	0x100007f4
    2df0:	10000800 	.word	0x10000800
    2df4:	100007f8 	.word	0x100007f8
    2df8:	2009c09c 	.word	0x2009c09c
    2dfc:	2009c098 	.word	0x2009c098

Disassembly of section .text.gKey_Init:

00002e00 <gKey_Init>:
		// se desejar processar a tecla quando a mesma for pressionada, durante o pressionamento
		//		e quando soltar a tecla
//		gkey_Init(NULL, NULL, &onKeyUp);
		// se desejar processar a tecla somente a mesma for solta
void gKey_Init(pkeyFunc onKdown, pkeyFunc onKpress, pkeyFunc onKup) {
	onKeyDown = onKdown;
    2e00:	4b04      	ldr	r3, [pc, #16]	; (2e14 <gKey_Init+0x14>)
    2e02:	6018      	str	r0, [r3, #0]
	onKeyPress = onKpress;
    2e04:	4b04      	ldr	r3, [pc, #16]	; (2e18 <gKey_Init+0x18>)
    2e06:	6019      	str	r1, [r3, #0]
	onKeyUp = onKup;
    2e08:	4b04      	ldr	r3, [pc, #16]	; (2e1c <gKey_Init+0x1c>)
    2e0a:	601a      	str	r2, [r3, #0]
	gkey_FastInc = 0; // sem repetição
    2e0c:	4b04      	ldr	r3, [pc, #16]	; (2e20 <gKey_Init+0x20>)
    2e0e:	2200      	movs	r2, #0
    2e10:	601a      	str	r2, [r3, #0]
    2e12:	4770      	bx	lr
    2e14:	10000818 	.word	0x10000818
    2e18:	10000824 	.word	0x10000824
    2e1c:	1000080c 	.word	0x1000080c
    2e20:	100005ec 	.word	0x100005ec

Disassembly of section .text.gKey_Tick:

00002e24 <gKey_Tick>:


// função a ser chamada a cada 1ms
static volatile uint timeRepeat=0;
void gKey_Tick(void) {
	if (timeRepeat) timeRepeat--;
    2e24:	4b03      	ldr	r3, [pc, #12]	; (2e34 <gKey_Tick+0x10>)
    2e26:	681a      	ldr	r2, [r3, #0]
    2e28:	b112      	cbz	r2, 2e30 <gKey_Tick+0xc>
    2e2a:	681a      	ldr	r2, [r3, #0]
    2e2c:	3a01      	subs	r2, #1
    2e2e:	601a      	str	r2, [r3, #0]
    2e30:	4770      	bx	lr
    2e32:	bf00      	nop
    2e34:	10000810 	.word	0x10000810

Disassembly of section .text.gKey_Process:

00002e38 <gKey_Process>:

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    2e38:	b570      	push	{r4, r5, r6, lr}
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    2e3a:	4a21      	ldr	r2, [pc, #132]	; (2ec0 <gKey_Process+0x88>)
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    2e3c:	4d21      	ldr	r5, [pc, #132]	; (2ec4 <gKey_Process+0x8c>)
void gKey_Process(char key) {
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    2e3e:	7813      	ldrb	r3, [r2, #0]
    keynow = key;
    2e40:	7010      	strb	r0, [r2, #0]

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    2e42:	782a      	ldrb	r2, [r5, #0]

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    2e44:	4604      	mov	r4, r0
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    2e46:	b112      	cbz	r2, 2e4e <gKey_Process+0x16>
    2e48:	2a01      	cmp	r2, #1
    2e4a:	d018      	beq.n	2e7e <gKey_Process+0x46>
    2e4c:	bd70      	pop	{r4, r5, r6, pc}
    case 0: 									// Estado de verificação se tecla foi pressionada
    	repeat = keyREPEAT;						// A cada X segundos incrementos o gkey_FastInc
    2e4e:	491e      	ldr	r1, [pc, #120]	; (2ec8 <gKey_Process+0x90>)
    2e50:	260a      	movs	r6, #10
    2e52:	600e      	str	r6, [r1, #0]
		gkey_FastInc = 0;						// Sinaliza para não incrementar de modo rápido
    2e54:	491d      	ldr	r1, [pc, #116]	; (2ecc <gKey_Process+0x94>)
    2e56:	600a      	str	r2, [r1, #0]
    	if ((keyold==0)&&(keynow!=0)) {			// Checa se é a descida da tecla, se sim emitir o evento onKeyDown e onKeyPress
    2e58:	2b00      	cmp	r3, #0
    2e5a:	d12f      	bne.n	2ebc <gKey_Process+0x84>
    2e5c:	2800      	cmp	r0, #0
    2e5e:	d02d      	beq.n	2ebc <gKey_Process+0x84>
            if (onKeyDown) onKeyDown(key);		// Emitir o evento onKeyDown e onKeyPress
    2e60:	4b1b      	ldr	r3, [pc, #108]	; (2ed0 <gKey_Process+0x98>)
    2e62:	681b      	ldr	r3, [r3, #0]
    2e64:	b103      	cbz	r3, 2e68 <gKey_Process+0x30>
    2e66:	4798      	blx	r3
            if (onKeyPress) onKeyPress(key);	// Emitir o evento onKeyPress
    2e68:	4b1a      	ldr	r3, [pc, #104]	; (2ed4 <gKey_Process+0x9c>)
    2e6a:	681b      	ldr	r3, [r3, #0]
    2e6c:	b10b      	cbz	r3, 2e72 <gKey_Process+0x3a>
    2e6e:	4620      	mov	r0, r4
    2e70:	4798      	blx	r3
            timeRepeat = keyKEYPRESS_REPEAT1;	// Determina em que tempo vamos repetir o evento onKeyPress após a primeira vez
    2e72:	4b19      	ldr	r3, [pc, #100]	; (2ed8 <gKey_Process+0xa0>)
    2e74:	f44f 72fa 	mov.w	r2, #500	; 0x1f4
    2e78:	601a      	str	r2, [r3, #0]
    		estado = 1;							// Vá para o estado de verificação de tecla precionada
    2e7a:	2301      	movs	r3, #1
    2e7c:	e007      	b.n	2e8e <gKey_Process+0x56>
    	}
    	break;
    case 1: 									// Estado de verificação se a tecla esta sendo pressionada ou tecla foi solta
    	if ((keyold!=0)&&(keynow==0)) {			// Checa se é a subida da tecla, se sim emitir o evento onKeyUp
    2e7e:	b143      	cbz	r3, 2e92 <gKey_Process+0x5a>
    2e80:	b938      	cbnz	r0, 2e92 <gKey_Process+0x5a>
    		if (onKeyUp) onKeyUp(keyold);
    2e82:	4a16      	ldr	r2, [pc, #88]	; (2edc <gKey_Process+0xa4>)
    2e84:	6812      	ldr	r2, [r2, #0]
    2e86:	b10a      	cbz	r2, 2e8c <gKey_Process+0x54>
    2e88:	4618      	mov	r0, r3
    2e8a:	4790      	blx	r2
    		estado = 0;							// Volta ao estado para esperar a próxima tecla a ser pressionada
    2e8c:	2300      	movs	r3, #0
    2e8e:	702b      	strb	r3, [r5, #0]
    2e90:	bd70      	pop	{r4, r5, r6, pc}
    	} else if (timeRepeat == 0) {					// Checa se está na hora de repetir o evento onKeyPress
    2e92:	4b11      	ldr	r3, [pc, #68]	; (2ed8 <gKey_Process+0xa0>)
    2e94:	681a      	ldr	r2, [r3, #0]
    2e96:	b98a      	cbnz	r2, 2ebc <gKey_Process+0x84>
            timeRepeat = keyKEYPRESS_REPEAT2; 		// Determina em que tempo vamos repetir o evento onKeyPress sucessivamente quando a tecla for mantida pressionada
    2e98:	2264      	movs	r2, #100	; 0x64
    2e9a:	601a      	str	r2, [r3, #0]
            if (onKeyPress) onKeyPress(key);	// Chama o evento onKeyPress
    2e9c:	4b0d      	ldr	r3, [pc, #52]	; (2ed4 <gKey_Process+0x9c>)
    2e9e:	681b      	ldr	r3, [r3, #0]
    2ea0:	b10b      	cbz	r3, 2ea6 <gKey_Process+0x6e>
    2ea2:	4620      	mov	r0, r4
    2ea4:	4798      	blx	r3

            // checar o momento de incrementar a var FastInc
            if (repeat) repeat--;
    2ea6:	4a08      	ldr	r2, [pc, #32]	; (2ec8 <gKey_Process+0x90>)
    2ea8:	6813      	ldr	r3, [r2, #0]
    2eaa:	b10b      	cbz	r3, 2eb0 <gKey_Process+0x78>
    2eac:	3b01      	subs	r3, #1
    2eae:	e004      	b.n	2eba <gKey_Process+0x82>
            else {
            	repeat = keyREPEAT;
    2eb0:	230a      	movs	r3, #10
    2eb2:	6013      	str	r3, [r2, #0]
            	gkey_FastInc++;
    2eb4:	4a05      	ldr	r2, [pc, #20]	; (2ecc <gKey_Process+0x94>)
    2eb6:	6813      	ldr	r3, [r2, #0]
    2eb8:	3301      	adds	r3, #1
    2eba:	6013      	str	r3, [r2, #0]
    2ebc:	bd70      	pop	{r4, r5, r6, pc}
    2ebe:	bf00      	nop
    2ec0:	1000081c 	.word	0x1000081c
    2ec4:	10000814 	.word	0x10000814
    2ec8:	10000820 	.word	0x10000820
    2ecc:	100005ec 	.word	0x100005ec
    2ed0:	10000818 	.word	0x10000818
    2ed4:	10000824 	.word	0x10000824
    2ed8:	10000810 	.word	0x10000810
    2edc:	1000080c 	.word	0x1000080c

Disassembly of section .text.beep_SetType:

00002ee0 <beep_SetType>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Ajusta o controlador a emitir o tipo sonoro
// -------------------------------------------------------------------------------------------------------------------
static void beep_SetType(void) {
	uint x; for(x=0;x<nPULSE_BEEPS;x++) { beep.pulse[x].tOff = 0; beep.pulse[x].tOn = 0;}
    2ee0:	4b26      	ldr	r3, [pc, #152]	; (2f7c <beep_SetType+0x9c>)
    2ee2:	2200      	movs	r2, #0
    2ee4:	615a      	str	r2, [r3, #20]
    2ee6:	611a      	str	r2, [r3, #16]
    2ee8:	61da      	str	r2, [r3, #28]
    2eea:	619a      	str	r2, [r3, #24]
    2eec:	625a      	str	r2, [r3, #36]	; 0x24
    2eee:	621a      	str	r2, [r3, #32]
	beep.index = 0;
    2ef0:	60da      	str	r2, [r3, #12]
	beep.interval = 0;
    2ef2:	62da      	str	r2, [r3, #44]	; 0x2c

	switch(beep.type) {
    2ef4:	685a      	ldr	r2, [r3, #4]
    2ef6:	3a02      	subs	r2, #2
    2ef8:	2a05      	cmp	r2, #5
    2efa:	d83d      	bhi.n	2f78 <beep_SetType+0x98>
    2efc:	e8df f002 	tbb	[pc, r2]
    2f00:	1b090313 	.word	0x1b090313
    2f04:	2f23      	.short	0x2f23
	case beep1SHORTBEEP:
 		beep.nBeeps = 1; // Emitir 1 beep
    2f06:	2201      	movs	r2, #1
    2f08:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 50; // Primeiro beep 50 ms ligado
    2f0a:	2232      	movs	r2, #50	; 0x32
    2f0c:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 50; // Primeiro beep 50 ms desligado
    2f0e:	615a      	str	r2, [r3, #20]
    2f10:	e023      	b.n	2f5a <beep_SetType+0x7a>
 		beep.intervalLoad = 0; // sem repetições
		break;

	case beep3SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    2f12:	2203      	movs	r2, #3
    2f14:	609a      	str	r2, [r3, #8]
		for(x=0;x<3;x++) { beep.pulse[x].tOff = 50; beep.pulse[x].tOn = 50;} // todos os beeps 50ms ligado e desligado
    2f16:	2232      	movs	r2, #50	; 0x32
    2f18:	615a      	str	r2, [r3, #20]
    2f1a:	611a      	str	r2, [r3, #16]
    2f1c:	61da      	str	r2, [r3, #28]
    2f1e:	619a      	str	r2, [r3, #24]
    2f20:	625a      	str	r2, [r3, #36]	; 0x24
    2f22:	621a      	str	r2, [r3, #32]
    2f24:	e019      	b.n	2f5a <beep_SetType+0x7a>
		beep.intervalLoad = 0; // sem repetições
		break;

	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
    2f26:	2201      	movs	r2, #1
    2f28:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    2f2a:	f44f 7148 	mov.w	r1, #800	; 0x320
		beep.intervalLoad = 0; // sem repetições
		break;

	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    2f2e:	2264      	movs	r2, #100	; 0x64
    2f30:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    2f32:	6159      	str	r1, [r3, #20]
    2f34:	e01f      	b.n	2f76 <beep_SetType+0x96>
 		beep.intervalLoad = 100; // repetir os beeps a cada 100ms
		break;

	case beepCONTINUOUS_2xONOFF:
		beep.nBeeps = 2; // Emitir 2 beeps
    2f36:	2202      	movs	r2, #2
    2f38:	609a      	str	r2, [r3, #8]
		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    2f3a:	2264      	movs	r2, #100	; 0x64
    2f3c:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    2f3e:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 100; // Segundo beep 100 ms ligado
    2f40:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 100; // Segundo beep 100 ms desligado
    2f42:	61da      	str	r2, [r3, #28]
    2f44:	e015      	b.n	2f72 <beep_SetType+0x92>
 		beep.intervalLoad = 2000; // repetir os beeps a cada 2000ms
		break;

	case beep1LONG2SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    2f46:	2203      	movs	r2, #3
    2f48:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    2f4a:	2264      	movs	r2, #100	; 0x64
    2f4c:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    2f4e:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 50; // Segundo beep 50 ms ligado
    2f50:	2232      	movs	r2, #50	; 0x32
    2f52:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 50; // Segundo beep 50 ms desligado
    2f54:	61da      	str	r2, [r3, #28]
 		beep.pulse[2].tOn = 50; // Terceiro beep 50 ms ligado
    2f56:	621a      	str	r2, [r3, #32]
 		beep.pulse[2].tOff = 50; // Terceiro beep 50 ms desligado
    2f58:	625a      	str	r2, [r3, #36]	; 0x24
		beep.intervalLoad = 0; // sem repetições
    2f5a:	2200      	movs	r2, #0
    2f5c:	e00b      	b.n	2f76 <beep_SetType+0x96>
		break;

	case beepCONTINUOUS_1LONG2SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    2f5e:	2203      	movs	r2, #3
    2f60:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    2f62:	2264      	movs	r2, #100	; 0x64
    2f64:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    2f66:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 50; // Segundo beep 50 ms ligado
    2f68:	2232      	movs	r2, #50	; 0x32
    2f6a:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 50; // Segundo beep 50 ms desligado
    2f6c:	61da      	str	r2, [r3, #28]
 		beep.pulse[2].tOn = 50; // Terceiro beep 50 ms ligado
    2f6e:	621a      	str	r2, [r3, #32]
 		beep.pulse[2].tOff = 50; // Terceiro beep 50 ms desligado
    2f70:	625a      	str	r2, [r3, #36]	; 0x24
		beep.intervalLoad = 2000; // repetir os beeps a cada 2000ms
    2f72:	f44f 62fa 	mov.w	r2, #2000	; 0x7d0
    2f76:	629a      	str	r2, [r3, #40]	; 0x28
    2f78:	4770      	bx	lr
    2f7a:	bf00      	nop
    2f7c:	10000828 	.word	0x10000828

Disassembly of section .text.beep_Init:

00002f80 <beep_Init>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Inicializa o gerenciador de beeps
// -------------------------------------------------------------------------------------------------------------------
void beep_Init(void) {
	beep_SetupPorts();
    2f80:	4a07      	ldr	r2, [pc, #28]	; (2fa0 <beep_Init+0x20>)
    2f82:	6813      	ldr	r3, [r2, #0]
    2f84:	f043 43c0 	orr.w	r3, r3, #1610612736	; 0x60000000
    2f88:	6013      	str	r3, [r2, #0]
    2f8a:	4b06      	ldr	r3, [pc, #24]	; (2fa4 <beep_Init+0x24>)
    2f8c:	f04f 42c0 	mov.w	r2, #1610612736	; 0x60000000
    2f90:	601a      	str	r2, [r3, #0]
	beep.power = pdOFF; 	// Mantém desligado e emissão de beeps
    2f92:	4b05      	ldr	r3, [pc, #20]	; (2fa8 <beep_Init+0x28>)
    2f94:	781a      	ldrb	r2, [r3, #0]
    2f96:	f36f 0200 	bfc	r2, #0, #1
    2f9a:	701a      	strb	r2, [r3, #0]
    2f9c:	4770      	bx	lr
    2f9e:	bf00      	nop
    2fa0:	2009c000 	.word	0x2009c000
    2fa4:	2009c01c 	.word	0x2009c01c
    2fa8:	10000828 	.word	0x10000828

Disassembly of section .text.beep_Play:

00002fac <beep_Play>:
//			beep1SHORTBEEP 			Emissão de um beep curto
//			beep3SHORTBEEP 			Emissão de três beeps curtos
//			beepCONTINUOUS_2xONOFF	Emissão de dois beeps curtos em intervalos
//			beep1LONG2SHORTBEEP		Emissão um beep longo e dois beeps curtos
// -------------------------------------------------------------------------------------------------------------------
void beep_Play(uint type) {
    2fac:	b510      	push	{r4, lr}
    2fae:	4c07      	ldr	r4, [pc, #28]	; (2fcc <beep_Play+0x20>)
	if (type) {
    2fb0:	b130      	cbz	r0, 2fc0 <beep_Play+0x14>
		beep.type = type;
    2fb2:	6060      	str	r0, [r4, #4]
		beep_SetType();
    2fb4:	f7ff ff94 	bl	2ee0 <beep_SetType>
		beep.power = pdON;
    2fb8:	7823      	ldrb	r3, [r4, #0]
    2fba:	f043 0301 	orr.w	r3, r3, #1
    2fbe:	e002      	b.n	2fc6 <beep_Play+0x1a>
	} else beep.power = pdOFF;
    2fc0:	7823      	ldrb	r3, [r4, #0]
    2fc2:	f360 0300 	bfi	r3, r0, #0, #1
    2fc6:	7023      	strb	r3, [r4, #0]
    2fc8:	bd10      	pop	{r4, pc}
    2fca:	bf00      	nop
    2fcc:	10000828 	.word	0x10000828

Disassembly of section .text.beep_Tick:

00002fd0 <beep_Tick>:
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    2fd0:	481f      	ldr	r0, [pc, #124]	; (3050 <beep_Tick+0x80>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Evento a ser chamado a cada 1ms para control de emissão sonora
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
    2fd2:	b510      	push	{r4, lr}
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    2fd4:	7802      	ldrb	r2, [r0, #0]
    2fd6:	07d3      	lsls	r3, r2, #31
    2fd8:	d403      	bmi.n	2fe2 <beep_Tick+0x12>
		beep_BuzzerOFF();
    2fda:	f04f 42c0 	mov.w	r2, #1610612736	; 0x60000000
    2fde:	4b1d      	ldr	r3, [pc, #116]	; (3054 <beep_Tick+0x84>)
    2fe0:	e005      	b.n	2fee <beep_Tick+0x1e>
		return;
	}

	// se é o beep acionado direto liga o buzzer e cai fora
	if (beep.type == beepCONTINUOUS) {
    2fe2:	6843      	ldr	r3, [r0, #4]
    2fe4:	2b01      	cmp	r3, #1
    2fe6:	d104      	bne.n	2ff2 <beep_Tick+0x22>
		beep_BuzzerON();
    2fe8:	4b1b      	ldr	r3, [pc, #108]	; (3058 <beep_Tick+0x88>)
    2fea:	f04f 42c0 	mov.w	r2, #1610612736	; 0x60000000
    2fee:	601a      	str	r2, [r3, #0]
		return;
    2ff0:	bd10      	pop	{r4, pc}
	}

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
    2ff2:	6ac3      	ldr	r3, [r0, #44]	; 0x2c
    2ff4:	b10b      	cbz	r3, 2ffa <beep_Tick+0x2a>
    2ff6:	3b01      	subs	r3, #1
    2ff8:	e023      	b.n	3042 <beep_Tick+0x72>
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
    2ffa:	68c1      	ldr	r1, [r0, #12]
    2ffc:	1c8b      	adds	r3, r1, #2
    2ffe:	f850 4033 	ldr.w	r4, [r0, r3, lsl #3]
    3002:	b13c      	cbz	r4, 3014 <beep_Tick+0x44>
			beep_BuzzerON(); // Liga o buzzer
    3004:	4a14      	ldr	r2, [pc, #80]	; (3058 <beep_Tick+0x88>)
    3006:	f04f 41c0 	mov.w	r1, #1610612736	; 0x60000000
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    300a:	3c01      	subs	r4, #1

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
    300c:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    300e:	f840 4033 	str.w	r4, [r0, r3, lsl #3]
    3012:	bd10      	pop	{r4, pc}
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
    3014:	eb00 03c3 	add.w	r3, r0, r3, lsl #3
    3018:	685c      	ldr	r4, [r3, #4]
    301a:	b134      	cbz	r4, 302a <beep_Tick+0x5a>
			beep_BuzzerOFF(); // desliga o buzzer
    301c:	4a0d      	ldr	r2, [pc, #52]	; (3054 <beep_Tick+0x84>)
    301e:	f04f 41c0 	mov.w	r1, #1610612736	; 0x60000000
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    3022:	3c01      	subs	r4, #1
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
			beep_BuzzerOFF(); // desliga o buzzer
    3024:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    3026:	605c      	str	r4, [r3, #4]
    3028:	bd10      	pop	{r4, pc}
		// Vamos verificar se fez todos os beeps e se é para tocar de forma continua o não,
		//	se sim vamos recomeçar, senão para tudo
		} else {
			if (beep.index < (beep.nBeeps-1)) // Checa se fez todos os beeps
    302a:	6883      	ldr	r3, [r0, #8]
    302c:	3b01      	subs	r3, #1
    302e:	4299      	cmp	r1, r3
    3030:	d202      	bcs.n	3038 <beep_Tick+0x68>
				beep.index++; // vai para o próximo beep
    3032:	3101      	adds	r1, #1
    3034:	60c1      	str	r1, [r0, #12]
    3036:	bd10      	pop	{r4, pc}
			else {
				// se fez todos os beeps vamos checar se tem intervalo entre eles, se tiver vamos reiniciar
				// senão pata tudo
				if (beep.intervalLoad) {
    3038:	6a81      	ldr	r1, [r0, #40]	; 0x28
    303a:	b121      	cbz	r1, 3046 <beep_Tick+0x76>
					beep_SetType(); // reinicia as variáveis
    303c:	f7ff ff50 	bl	2ee0 <beep_SetType>
					beep.interval = beep.intervalLoad; // Captura o intervalo
    3040:	6a83      	ldr	r3, [r0, #40]	; 0x28
    3042:	62c3      	str	r3, [r0, #44]	; 0x2c
    3044:	bd10      	pop	{r4, pc}
				} else beep.power = pdOFF; // desliga tudo
    3046:	4613      	mov	r3, r2
    3048:	f361 0300 	bfi	r3, r1, #0, #1
    304c:	7003      	strb	r3, [r0, #0]
    304e:	bd10      	pop	{r4, pc}
    3050:	10000828 	.word	0x10000828
    3054:	2009c01c 	.word	0x2009c01c
    3058:	2009c018 	.word	0x2009c018

Disassembly of section .text.cli_GetLine:

0000305c <cli_GetLine>:
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    305c:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
  	if (initGet) { // Checa se é incio da entrada de comandos
    305e:	4f35      	ldr	r7, [pc, #212]	; (3134 <cli_GetLine+0xd8>)
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    3060:	4604      	mov	r4, r0
  	if (initGet) { // Checa se é incio da entrada de comandos
    3062:	783b      	ldrb	r3, [r7, #0]
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    3064:	460e      	mov	r6, r1
  	if (initGet) { // Checa se é incio da entrada de comandos
    3066:	b143      	cbz	r3, 307a <cli_GetLine+0x1e>
  		lprintf("%s", prompt);
    3068:	4933      	ldr	r1, [pc, #204]	; (3138 <cli_GetLine+0xdc>)
    306a:	2001      	movs	r0, #1
    306c:	f7ff fd76 	bl	2b5c <rprintf>
  	  	p = buffer;
    3070:	4b32      	ldr	r3, [pc, #200]	; (313c <cli_GetLine+0xe0>)
    3072:	601c      	str	r4, [r3, #0]
  	  	*p = '\0';
    3074:	2300      	movs	r3, #0
    3076:	7023      	strb	r3, [r4, #0]
  	  	initGet = 0;
    3078:	703b      	strb	r3, [r7, #0]
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
    307a:	4d31      	ldr	r5, [pc, #196]	; (3140 <cli_GetLine+0xe4>)
    307c:	4628      	mov	r0, r5
    307e:	f7ff fd67 	bl	2b50 <lgetchar>
    3082:	2801      	cmp	r0, #1
    3084:	4603      	mov	r3, r0
    3086:	d150      	bne.n	312a <cli_GetLine+0xce>
	  	switch (c) {
    3088:	782a      	ldrb	r2, [r5, #0]
    308a:	2a0d      	cmp	r2, #13
    308c:	d010      	beq.n	30b0 <cli_GetLine+0x54>
    308e:	d804      	bhi.n	309a <cli_GetLine+0x3e>
    3090:	2a08      	cmp	r2, #8
    3092:	d018      	beq.n	30c6 <cli_GetLine+0x6a>
    3094:	2a0a      	cmp	r2, #10
    3096:	d00b      	beq.n	30b0 <cli_GetLine+0x54>
    3098:	e031      	b.n	30fe <cli_GetLine+0xa2>
    309a:	2a15      	cmp	r2, #21
    309c:	d101      	bne.n	30a2 <cli_GetLine+0x46>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    309e:	4d27      	ldr	r5, [pc, #156]	; (313c <cli_GetLine+0xe0>)
    30a0:	e01f      	b.n	30e2 <cli_GetLine+0x86>
  	  	initGet = 0;
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
    30a2:	d32c      	bcc.n	30fe <cli_GetLine+0xa2>
    30a4:	2afe      	cmp	r2, #254	; 0xfe
    30a6:	d32a      	bcc.n	30fe <cli_GetLine+0xa2>
      		*p = '\0';
      		break;

	    case 0xfe :
    	case 0xff :
        	*buffer++ = c;
    30a8:	7022      	strb	r2, [r4, #0]
        	*buffer = '\0';
    30aa:	2200      	movs	r2, #0
    30ac:	7062      	strb	r2, [r4, #1]
        	return 1;
    30ae:	e03f      	b.n	3130 <cli_GetLine+0xd4>
  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    30b0:	4924      	ldr	r1, [pc, #144]	; (3144 <cli_GetLine+0xe8>)
    30b2:	2001      	movs	r0, #1
    30b4:	f7ff fd52 	bl	2b5c <rprintf>
    		initGet = 1;
    30b8:	2301      	movs	r3, #1
    30ba:	703b      	strb	r3, [r7, #0]
    		return strlen ((char *) buffer);
    30bc:	4620      	mov	r0, r4
      	}
    }
  	//}

  	return 0;
}
    30be:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    		initGet = 1;
    		return strlen ((char *) buffer);
    30c2:	f000 bb8f 	b.w	37e4 <strlen>

    	case '\b' :
    		if (p > buffer) {
    30c6:	4a1d      	ldr	r2, [pc, #116]	; (313c <cli_GetLine+0xe0>)
    30c8:	6813      	ldr	r3, [r2, #0]
    30ca:	429c      	cmp	r4, r3
    30cc:	f04f 0400 	mov.w	r4, #0
    30d0:	d22d      	bcs.n	312e <cli_GetLine+0xd2>
    			*--p = '\0';
    30d2:	1e59      	subs	r1, r3, #1
    30d4:	6011      	str	r1, [r2, #0]
    30d6:	f803 4c01 	strb.w	r4, [r3, #-1]
        		lprintf("\b \b");
    30da:	491b      	ldr	r1, [pc, #108]	; (3148 <cli_GetLine+0xec>)
    30dc:	f7ff fd3e 	bl	2b5c <rprintf>
    30e0:	e025      	b.n	312e <cli_GetLine+0xd2>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    30e2:	682b      	ldr	r3, [r5, #0]
    30e4:	429c      	cmp	r4, r3
    30e6:	d007      	beq.n	30f8 <cli_GetLine+0x9c>
    			lprintf("\b \b");
    30e8:	4917      	ldr	r1, [pc, #92]	; (3148 <cli_GetLine+0xec>)
    30ea:	2001      	movs	r0, #1
    30ec:	f7ff fd36 	bl	2b5c <rprintf>
            	--p;
    30f0:	682b      	ldr	r3, [r5, #0]
    30f2:	3b01      	subs	r3, #1
    30f4:	602b      	str	r3, [r5, #0]
    30f6:	e7f4      	b.n	30e2 <cli_GetLine+0x86>
	        }
      		*p = '\0';
    30f8:	2300      	movs	r3, #0
    30fa:	7023      	strb	r3, [r4, #0]
      		break;
    30fc:	e018      	b.n	3130 <cli_GetLine+0xd4>
        	*buffer++ = c;
        	*buffer = '\0';
        	return 1;
	        		
	    default :
	    	if (p < buffer + bufferLength - 1 && c >= ' ' && c < 0x7f) {
    30fe:	490f      	ldr	r1, [pc, #60]	; (313c <cli_GetLine+0xe0>)
    3100:	3e01      	subs	r6, #1
    3102:	680b      	ldr	r3, [r1, #0]
    3104:	4434      	add	r4, r6
    3106:	42a3      	cmp	r3, r4
    3108:	d20f      	bcs.n	312a <cli_GetLine+0xce>
    310a:	f1a2 0020 	sub.w	r0, r2, #32
    310e:	285e      	cmp	r0, #94	; 0x5e
    3110:	f04f 0400 	mov.w	r4, #0
    3114:	d80b      	bhi.n	312e <cli_GetLine+0xd2>
        		*p++ = c;
    3116:	1c58      	adds	r0, r3, #1
    3118:	701a      	strb	r2, [r3, #0]
    311a:	6008      	str	r0, [r1, #0]
            	*p = '\0';
    311c:	705c      	strb	r4, [r3, #1]
            	lprintf("%c", c);
    311e:	782a      	ldrb	r2, [r5, #0]
    3120:	490a      	ldr	r1, [pc, #40]	; (314c <cli_GetLine+0xf0>)
    3122:	2001      	movs	r0, #1
    3124:	f7ff fd1a 	bl	2b5c <rprintf>
    3128:	e001      	b.n	312e <cli_GetLine+0xd2>
	    	break;
      	}
    }
  	//}

  	return 0;
    312a:	2300      	movs	r3, #0
    312c:	e000      	b.n	3130 <cli_GetLine+0xd4>
    312e:	4623      	mov	r3, r4
}
    3130:	4618      	mov	r0, r3
    3132:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    3134:	10000034 	.word	0x10000034
    3138:	00003f3d 	.word	0x00003f3d
    313c:	1000085c 	.word	0x1000085c
    3140:	10000860 	.word	0x10000860
    3144:	00003c77 	.word	0x00003c77
    3148:	00003f40 	.word	0x00003f40
    314c:	00003f26 	.word	0x00003f26

Disassembly of section .text.cli_Help:

00003150 <cli_Help>:
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    3150:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    3154:	2500      	movs	r5, #0
    3156:	462c      	mov	r4, r5
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    3158:	b08a      	sub	sp, #40	; 0x28
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    315a:	2220      	movs	r2, #32

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    315c:	4e1e      	ldr	r6, [pc, #120]	; (31d8 <cli_Help+0x88>)
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    315e:	4611      	mov	r1, r2
    3160:	a802      	add	r0, sp, #8
    3162:	f000 faf1 	bl	3748 <memset>

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    3166:	6837      	ldr	r7, [r6, #0]
    3168:	3514      	adds	r5, #20
    316a:	197b      	adds	r3, r7, r5
    316c:	f853 0c14 	ldr.w	r0, [r3, #-20]
    3170:	b128      	cbz	r0, 317e <cli_Help+0x2e>
    	if ((t = strlen (cmd_list_active[i].command)) > longestCmd)
    3172:	f000 fb37 	bl	37e4 <strlen>
    3176:	4284      	cmp	r4, r0
    3178:	bfb8      	it	lt
    317a:	4604      	movlt	r4, r0
    317c:	e7f4      	b.n	3168 <cli_Help+0x18>
      		longestCmd = t;

  	spaces [longestCmd] = '\0';
    317e:	ab0a      	add	r3, sp, #40	; 0x28
    3180:	441c      	add	r4, r3
    3182:	f804 0c20 	strb.w	r0, [r4, #-32]

  	for (i = 0; cmd_list_active[i].command; i++) {
    3186:	4604      	mov	r4, r0
    3188:	6833      	ldr	r3, [r6, #0]
    318a:	591d      	ldr	r5, [r3, r4]
    318c:	191a      	adds	r2, r3, r4
    318e:	b1dd      	cbz	r5, 31c8 <cli_Help+0x78>
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    3190:	f892 8006 	ldrb.w	r8, [r2, #6]
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    3194:	4628      	mov	r0, r5
  	spaces [longestCmd] = '\0';

  	for (i = 0; cmd_list_active[i].command; i++) {
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    3196:	f1b8 0f01 	cmp.w	r8, #1
    319a:	68d7      	ldr	r7, [r2, #12]
    319c:	d108      	bne.n	31b0 <cli_Help+0x60>
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    319e:	f000 fb21 	bl	37e4 <strlen>
    31a2:	ab02      	add	r3, sp, #8
    31a4:	4403      	add	r3, r0
    31a6:	9700      	str	r7, [sp, #0]
    31a8:	462a      	mov	r2, r5
    31aa:	490c      	ldr	r1, [pc, #48]	; (31dc <cli_Help+0x8c>)
    31ac:	4640      	mov	r0, r8
    31ae:	e007      	b.n	31c0 <cli_Help+0x70>
    	else
    		lprintf("%s%s -- " CLI_MSG_SUB_LIST " - %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    31b0:	f000 fb18 	bl	37e4 <strlen>
    31b4:	462a      	mov	r2, r5
    31b6:	ab02      	add	r3, sp, #8
    31b8:	4909      	ldr	r1, [pc, #36]	; (31e0 <cli_Help+0x90>)
    31ba:	4403      	add	r3, r0
    31bc:	9700      	str	r7, [sp, #0]
    31be:	2001      	movs	r0, #1
    31c0:	f7ff fccc 	bl	2b5c <rprintf>
    31c4:	3414      	adds	r4, #20
    31c6:	e7df      	b.n	3188 <cli_Help+0x38>
  	}

  	lprintf(CLI_MSG_HELP);
    31c8:	4906      	ldr	r1, [pc, #24]	; (31e4 <cli_Help+0x94>)
    31ca:	2001      	movs	r0, #1
    31cc:	f7ff fcc6 	bl	2b5c <rprintf>

  	return pdPASS;
}
    31d0:	2001      	movs	r0, #1
    31d2:	b00a      	add	sp, #40	; 0x28
    31d4:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    31d8:	10000858 	.word	0x10000858
    31dc:	00003f44 	.word	0x00003f44
    31e0:	00003f50 	.word	0x00003f50
    31e4:	00003f66 	.word	0x00003f66

Disassembly of section .text.cli_ArgsParse:

000031e8 <cli_ArgsParse>:
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    31e8:	e92d 47f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
    31ec:	4604      	mov	r4, r0
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    31ee:	0897      	lsrs	r7, r2, #2
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    31f0:	460e      	mov	r6, r1
    31f2:	4691      	mov	r9, r2
    31f4:	4698      	mov	r8, r3
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    31f6:	f000 faf5 	bl	37e4 <strlen>
    31fa:	3801      	subs	r0, #1
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    31fc:	3f01      	subs	r7, #1
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    31fe:	1825      	adds	r5, r4, r0

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    3200:	f04f 0a00 	mov.w	sl, #0
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
    3204:	42ac      	cmp	r4, r5
    3206:	d813      	bhi.n	3230 <cli_ArgsParse+0x48>
    3208:	782b      	ldrb	r3, [r5, #0]
    320a:	b18b      	cbz	r3, 3230 <cli_ArgsParse+0x48>
    320c:	f000 fa7c 	bl	3708 <__locale_ctype_ptr>
    3210:	782b      	ldrb	r3, [r5, #0]
    3212:	4418      	add	r0, r3
    3214:	7843      	ldrb	r3, [r0, #1]
    3216:	071b      	lsls	r3, r3, #28
    3218:	d50a      	bpl.n	3230 <cli_ArgsParse+0x48>
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    321a:	f805 a901 	strb.w	sl, [r5], #-1
    321e:	e7f1      	b.n	3204 <cli_ArgsParse+0x1c>

  	// ENCONTRA O INICIO DO COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO ESQUERDO DA STRING
  	while (*s && isspace ((int)*s)) 		// Faça enquanto o endereço s seja menor que o endereço final da string e se o caractere for um whitespace
    3220:	f000 fa72 	bl	3708 <__locale_ctype_ptr>
    3224:	782b      	ldrb	r3, [r5, #0]
    3226:	3401      	adds	r4, #1
    3228:	4418      	add	r0, r3
    322a:	7843      	ldrb	r3, [r0, #1]
    322c:	0718      	lsls	r0, r3, #28
    322e:	d503      	bpl.n	3238 <cli_ArgsParse+0x50>
    3230:	7823      	ldrb	r3, [r4, #0]
    3232:	4625      	mov	r5, r4
    3234:	2b00      	cmp	r3, #0
    3236:	d1f3      	bne.n	3220 <cli_ArgsParse+0x38>
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    3238:	2400      	movs	r4, #0
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    323a:	464a      	mov	r2, r9
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    323c:	f8c8 4000 	str.w	r4, [r8]
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    3240:	4621      	mov	r1, r4
    3242:	4630      	mov	r0, r6
    3244:	f000 fa80 	bl	3748 <memset>

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    3248:	46a1      	mov	r9, r4
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    324a:	e010      	b.n	326e <cli_ArgsParse+0x86>

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    324c:	f8d8 3000 	ldr.w	r3, [r8]
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    3250:	6035      	str	r5, [r6, #0]

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    3252:	3301      	adds	r3, #1
    3254:	429f      	cmp	r7, r3
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    3256:	f106 0204 	add.w	r2, r6, #4

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    325a:	f8c8 3000 	str.w	r3, [r8]
    325e:	d036      	beq.n	32ce <cli_ArgsParse+0xe6>
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    3260:	4616      	mov	r6, r2

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
	          	if (*s == '"')								// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
    3262:	f815 3b01 	ldrb.w	r3, [r5], #1
    	        	pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametro 
        	  	else
            		pstate = P_SET_END_ARGS;				// Vai ao estado de de encontrar fim do argumento
    3266:	2b22      	cmp	r3, #34	; 0x22
    3268:	bf0c      	ite	eq
    326a:	2403      	moveq	r4, #3
    326c:	2402      	movne	r4, #2
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    326e:	782b      	ldrb	r3, [r5, #0]
    3270:	b353      	cbz	r3, 32c8 <cli_ArgsParse+0xe0>
    	switch (pstate) {
    3272:	2c03      	cmp	r4, #3
    3274:	d8fc      	bhi.n	3270 <cli_ArgsParse+0x88>
    3276:	a201      	add	r2, pc, #4	; (adr r2, 327c <cli_ArgsParse+0x94>)
    3278:	f852 f024 	ldr.w	pc, [r2, r4, lsl #2]
    327c:	0000328d 	.word	0x0000328d
    3280:	0000324d 	.word	0x0000324d
    3284:	0000329d 	.word	0x0000329d
    3288:	000032bb 	.word	0x000032bb
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
    328c:	f000 fa3c 	bl	3708 <__locale_ctype_ptr>
    3290:	782b      	ldrb	r3, [r5, #0]
    3292:	4418      	add	r0, r3
    3294:	7843      	ldrb	r3, [r0, #1]
    3296:	0719      	lsls	r1, r3, #28
    3298:	d514      	bpl.n	32c4 <cli_ArgsParse+0xdc>
    329a:	e011      	b.n	32c0 <cli_ArgsParse+0xd8>
    	    }
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
    329c:	f000 fa34 	bl	3708 <__locale_ctype_ptr>
    32a0:	782b      	ldrb	r3, [r5, #0]
    32a2:	4418      	add	r0, r3
    32a4:	7842      	ldrb	r2, [r0, #1]
    32a6:	0712      	lsls	r2, r2, #28
    32a8:	d503      	bpl.n	32b2 <cli_ArgsParse+0xca>
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    32aa:	f885 9000 	strb.w	r9, [r5]
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
    32ae:	2400      	movs	r4, #0
    32b0:	e006      	b.n	32c0 <cli_ArgsParse+0xd8>
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
          		}  else if (*s == '"')						// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
            		pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim do argumentos dentro das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametor 
    32b2:	2b22      	cmp	r3, #34	; 0x22
    32b4:	bf08      	it	eq
    32b6:	2403      	moveq	r4, #3
    32b8:	e002      	b.n	32c0 <cli_ArgsParse+0xd8>
       		}
        		break;

      		// ECONTRA O FIM DAS ASPAS PARA SINALIZAR FIM DE ARGUMENTO
      		case P_SET_END_QUOTE : {
          		if (*s == '"')	pstate = P_SET_END_ARGS;	// Checa se encontramos o caractere aspa. Sinaliza final do parametro e vá ao estado para procura do fim de argumento
    32ba:	2b22      	cmp	r3, #34	; 0x22
    32bc:	bf08      	it	eq
    32be:	2402      	moveq	r4, #2
          		
          		s++;										// Aponto para o próximo endereço do caractere do comando
    32c0:	3501      	adds	r5, #1
        	}
        		break;
    32c2:	e7d4      	b.n	326e <cli_ArgsParse+0x86>
  	while (*s) {											// Fazer para toda os caracteres do comando
    	switch (pstate) {
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
            		pstate = P_GET_INIT_ARGS;				// Sinalizo para ir para o estado de captura do argumento atual
    32c4:	2401      	movs	r4, #1
    32c6:	e7d2      	b.n	326e <cli_ArgsParse+0x86>
        	}
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
    32c8:	2001      	movs	r0, #1
    32ca:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
    32ce:	f06f 003b 	mvn.w	r0, #59	; 0x3b
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
}
    32d2:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
    32d6:	bf00      	nop

Disassembly of section .text.cli_ArgsDispatch:

000032d8 <cli_ArgsDispatch>:
//              Valor do retorno da função chamada
//              errCLI_CMD_NOT_FOUND: Se não encontrou o comando digitado na lista de comandos
//              errCLI_MANY_ARGS: Caso tenha muitos argumentos para o comando atual
//              errCLI_FEW_ARGS: Caso tenha pouco argumentos para o comando atual
// -----------------------------------------------------------------------------------------------------------------
int cli_ArgsDispatch (const tCLI *cl, int argc, char **argv) {
    32d8:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    32dc:	4604      	mov	r4, r0
    32de:	460d      	mov	r5, r1
    32e0:	4616      	mov	r6, r2
  	cmd_list_active = cl;
    32e2:	4f20      	ldr	r7, [pc, #128]	; (3364 <cli_ArgsDispatch+0x8c>)
    32e4:	603c      	str	r4, [r7, #0]

  	while (cl->command) { 								// Percorre toda lista de comandos
    32e6:	6820      	ldr	r0, [r4, #0]
    32e8:	2800      	cmp	r0, #0
    32ea:	d036      	beq.n	335a <cli_ArgsDispatch+0x82>
    	if (!strcmp (cl->command, argv [0])) {			// Checa se o comando atual é o mesmo digitado
    32ec:	6831      	ldr	r1, [r6, #0]
    32ee:	f7fd fedd 	bl	10ac <strcmp>
    32f2:	bb80      	cbnz	r0, 3356 <cli_ArgsDispatch+0x7e>
      		int ret = 0;

      		if ((argc == 2) && !strcmp (argv [1], "?")) { // Checa se foi digitaldo ? para o comando 
    32f4:	2d02      	cmp	r5, #2
    32f6:	d10c      	bne.n	3312 <cli_ArgsDispatch+0x3a>
    32f8:	491b      	ldr	r1, [pc, #108]	; (3368 <cli_ArgsDispatch+0x90>)
    32fa:	6870      	ldr	r0, [r6, #4]
    32fc:	f7fd fed6 	bl	10ac <strcmp>
    3300:	b938      	cbnz	r0, 3312 <cli_ArgsDispatch+0x3a>
        		lprintf("%s"CMD_TERMINATOR, cl->parameters);		// Exibe ajuda para os parametros
    3302:	6922      	ldr	r2, [r4, #16]
    3304:	4919      	ldr	r1, [pc, #100]	; (336c <cli_ArgsDispatch+0x94>)
    3306:	2001      	movs	r0, #1
    3308:	f7ff fc28 	bl	2b5c <rprintf>
        		ret = pdPASS;
    330c:	2001      	movs	r0, #1
    330e:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if ((argc - 1) < cl->min_args) {			// Checa se a quantidade de argumentos digitados é menor que o mínimo permitido
    3312:	7922      	ldrb	r2, [r4, #4]
    3314:	4295      	cmp	r5, r2
    3316:	dc07      	bgt.n	3328 <cli_ArgsDispatch+0x50>
        		lprintf(CLI_MSG_FEW_ARGS, cl->min_args);
    3318:	4915      	ldr	r1, [pc, #84]	; (3370 <cli_ArgsDispatch+0x98>)
    331a:	2001      	movs	r0, #1
    331c:	f7ff fc1e 	bl	2b5c <rprintf>
        		ret = errCLI_FEW_ARGS;
    3320:	f06f 003d 	mvn.w	r0, #61	; 0x3d
    3324:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if (cl->cmd_type == CMD_TYPE_LIST) {		// Checa se é um comando ou uma nome de outra lista
    3328:	79a3      	ldrb	r3, [r4, #6]
    332a:	1e68      	subs	r0, r5, #1
    332c:	b91b      	cbnz	r3, 3336 <cli_ArgsDispatch+0x5e>
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
    332e:	68a4      	ldr	r4, [r4, #8]
    3330:	4605      	mov	r5, r0
    3332:	3604      	adds	r6, #4
    3334:	e7d6      	b.n	32e4 <cli_ArgsDispatch+0xc>
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
    3336:	7962      	ldrb	r2, [r4, #5]
    3338:	4290      	cmp	r0, r2
    333a:	dd07      	ble.n	334c <cli_ArgsDispatch+0x74>
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
    333c:	490d      	ldr	r1, [pc, #52]	; (3374 <cli_ArgsDispatch+0x9c>)
    333e:	2001      	movs	r0, #1
    3340:	f7ff fc0c 	bl	2b5c <rprintf>
        		ret = errCLI_MANY_ARGS;
    3344:	f06f 003c 	mvn.w	r0, #60	; 0x3c
    3348:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    334c:	68a3      	ldr	r3, [r4, #8]
    334e:	1d31      	adds	r1, r6, #4

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
}
    3350:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
        		ret = errCLI_MANY_ARGS;
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    3354:	4718      	bx	r3
        	}

      		return ret;										// Retorna o valor de retorno da função ou 0 se não chamou função alguma
    	}

    	cl++;											// aponta para o próximo comando na lista 
    3356:	3414      	adds	r4, #20
    3358:	e7c5      	b.n	32e6 <cli_ArgsDispatch+0xe>
  	}

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
    335a:	f06f 003e 	mvn.w	r0, #62	; 0x3e
}
    335e:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    3362:	bf00      	nop
    3364:	10000858 	.word	0x10000858
    3368:	00003f91 	.word	0x00003f91
    336c:	00003f62 	.word	0x00003f62
    3370:	00003f93 	.word	0x00003f93
    3374:	00003fb4 	.word	0x00003fb4

Disassembly of section .text.lcd_command:

00003378 <lcd_command>:
  	_row_offsets[1] = row1;
  	_row_offsets[2] = row2;
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
    3378:	b510      	push	{r4, lr}
    337a:	4604      	mov	r4, r0
u8 _displaymode;
u8 _displayfunction;

// espera até o display estiver desocupado
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
    337c:	2000      	movs	r0, #0
    337e:	f000 f90b 	bl	3598 <lcd_read>
    3382:	0603      	lsls	r3, r0, #24
    3384:	d4fa      	bmi.n	337c <lcd_command+0x4>
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
  	lcd_busy();
	lcd_write_command(command);
    3386:	4620      	mov	r0, r4
}
    3388:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
  	lcd_busy();
	lcd_write_command(command);
    338c:	2100      	movs	r1, #0
    338e:	f000 b94b 	b.w	3628 <lcd_write>

Disassembly of section .text.lcd_PutChar:

00003392 <lcd_PutChar>:
}

// Imprime um caractere no display, no endereço atual da DDRAM apontado pelo reg AC.
//	O reg AC é incrementado automaticamente
// Esta função também é usada pelo rprintf
int lcd_PutChar(n16 ch) {
    3392:	b510      	push	{r4, lr}
    3394:	4604      	mov	r4, r0
u8 _displaymode;
u8 _displayfunction;

// espera até o display estiver desocupado
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
    3396:	2000      	movs	r0, #0
    3398:	f000 f8fe 	bl	3598 <lcd_read>
    339c:	0603      	lsls	r3, r0, #24
    339e:	d4fa      	bmi.n	3396 <lcd_PutChar+0x4>
// Imprime um caractere no display, no endereço atual da DDRAM apontado pelo reg AC.
//	O reg AC é incrementado automaticamente
// Esta função também é usada pelo rprintf
int lcd_PutChar(n16 ch) {
	lcd_busy();
	lcd_write_data((u8)ch);
    33a0:	b2e0      	uxtb	r0, r4
    33a2:	2101      	movs	r1, #1
    33a4:	f000 f940 	bl	3628 <lcd_write>
	return (int)ch;												// Retorna com o caractere a ser TX
}
    33a8:	4620      	mov	r0, r4
    33aa:	bd10      	pop	{r4, pc}

Disassembly of section .text.lcd_Clear:

000033ac <lcd_Clear>:
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
}

void lcd_Clear(void) {
    33ac:	b508      	push	{r3, lr}
  lcd_command(LCD_CLEAR_DISPLAY);  // clear display, set cursor position to zero
    33ae:	2001      	movs	r0, #1
    33b0:	f7ff ffe2 	bl	3378 <lcd_command>
  delay_ms(LCD_DELAY_HOME);  // this command takes a long time!
}
    33b4:	e8bd 4008 	ldmia.w	sp!, {r3, lr}
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
}

void lcd_Clear(void) {
  lcd_command(LCD_CLEAR_DISPLAY);  // clear display, set cursor position to zero
  delay_ms(LCD_DELAY_HOME);  // this command takes a long time!
    33b8:	4801      	ldr	r0, [pc, #4]	; (33c0 <lcd_Clear+0x14>)
    33ba:	f7fe bbdb 	b.w	1b74 <delay>
    33be:	bf00      	nop
    33c0:	000101d0 	.word	0x000101d0

Disassembly of section .text.lcd_SetCursor:

000033c4 <lcd_SetCursor>:
}

void lcd_SetCursor(u8 col, u8 row) {
  const uint max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
  if ( row >= max_lines ) row = max_lines - 1;    // we count rows starting w/0
  if ( row >= _numlines ) row = _numlines - 1;    // we count rows starting w/0
    33c4:	4b08      	ldr	r3, [pc, #32]	; (33e8 <lcd_SetCursor+0x24>)
    33c6:	2903      	cmp	r1, #3
    33c8:	781b      	ldrb	r3, [r3, #0]
    33ca:	bf28      	it	cs
    33cc:	2103      	movcs	r1, #3
    33ce:	428b      	cmp	r3, r1
    33d0:	bf9c      	itt	ls
    33d2:	f103 33ff 	addls.w	r3, r3, #4294967295
    33d6:	b2d9      	uxtbls	r1, r3

  lcd_command(LCD_SET_DDRAM_ADDR | (col + _row_offsets[row]));
    33d8:	4b04      	ldr	r3, [pc, #16]	; (33ec <lcd_SetCursor+0x28>)
    33da:	5c5b      	ldrb	r3, [r3, r1]
    33dc:	4418      	add	r0, r3
    33de:	f060 007f 	orn	r0, r0, #127	; 0x7f
    33e2:	b2c0      	uxtb	r0, r0
    33e4:	f7ff bfc8 	b.w	3378 <lcd_command>
    33e8:	100005f5 	.word	0x100005f5
    33ec:	100005f0 	.word	0x100005f0

Disassembly of section .text.lcd_Display:

000033f0 <lcd_Display>:
  _displaycontrol &= ~LCD_DISPLAY_ON;
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
}

void lcd_Display(void) {
  _displaycontrol |= LCD_DISPLAY_ON;
    33f0:	4b04      	ldr	r3, [pc, #16]	; (3404 <lcd_Display+0x14>)
    33f2:	7818      	ldrb	r0, [r3, #0]
    33f4:	f040 0204 	orr.w	r2, r0, #4
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
    33f8:	f040 000c 	orr.w	r0, r0, #12
  _displaycontrol &= ~LCD_DISPLAY_ON;
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
}

void lcd_Display(void) {
  _displaycontrol |= LCD_DISPLAY_ON;
    33fc:	701a      	strb	r2, [r3, #0]
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
    33fe:	f7ff bfbb 	b.w	3378 <lcd_command>
    3402:	bf00      	nop
    3404:	100005f4 	.word	0x100005f4

Disassembly of section .text.lcd_Init:

00003408 <lcd_Init>:
// Inicializa o display
// parametros:
//	cols: Número de colunas do LCD
//	lines: Número de linhas do LCD
//  dotsize: Tamanho da fonte em pontos: LCD_5x8DOTS ou LCD_5x10DOTS
void lcd_Init(u8 cols, u8 lines, u8 dotsize) {
    3408:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    340a:	460e      	mov	r6, r1
    340c:	4617      	mov	r7, r2
    340e:	4605      	mov	r5, r0
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_config_ports();
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
	lcd_config_ports();
    3410:	f000 f8ae 	bl	3570 <lcd_config_ports>
    3414:	4c21      	ldr	r4, [pc, #132]	; (349c <lcd_Init+0x94>)
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
    3416:	2e01      	cmp	r6, #1
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_config_ports();
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
	lcd_config_ports();
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
    3418:	bf94      	ite	ls
    341a:	f047 0310 	orrls.w	r3, r7, #16
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
    341e:	f047 0318 	orrhi.w	r3, r7, #24
    3422:	7023      	strb	r3, [r4, #0]
  	_numlines = lines;
    3424:	4b1e      	ldr	r3, [pc, #120]	; (34a0 <lcd_Init+0x98>)
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
    3426:	2200      	movs	r2, #0
	lcd_config_ports();
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
  	_numlines = lines;
    3428:	701e      	strb	r6, [r3, #0]
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
    342a:	4b1e      	ldr	r3, [pc, #120]	; (34a4 <lcd_Init+0x9c>)
    342c:	701a      	strb	r2, [r3, #0]
  	_row_offsets[1] = row1;
    342e:	2240      	movs	r2, #64	; 0x40
  	_row_offsets[2] = row2;
    3430:	709d      	strb	r5, [r3, #2]
  	_row_offsets[3] = row3;
    3432:	4415      	add	r5, r2
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
  	_row_offsets[1] = row1;
    3434:	705a      	strb	r2, [r3, #1]
  	_row_offsets[2] = row2;
  	_row_offsets[3] = row3;
    3436:	70dd      	strb	r5, [r3, #3]
  	_numlines = lines;

  	lcd_SetRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols);

  	// for some 1 line displays you can select a 10 pixel high font
  	if ((dotsize != LCD_5x8DOTS) && (lines == 1)) _displayfunction |= LCD_5x10DOTS;
    3438:	b12f      	cbz	r7, 3446 <lcd_Init+0x3e>
    343a:	2e01      	cmp	r6, #1
    343c:	bf02      	ittt	eq
    343e:	7823      	ldrbeq	r3, [r4, #0]
    3440:	f043 0304 	orreq.w	r3, r3, #4
    3444:	7023      	strbeq	r3, [r4, #0]

  	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  	// according to datasheet, we need at least 40ms after power rises above 2.7V
  	// before sending commands. CPU can turn on way before 4.5V so we'll wait 50
  	delay_ms(LCD_DELAY_INIT);
    3446:	4818      	ldr	r0, [pc, #96]	; (34a8 <lcd_Init+0xa0>)
    3448:	f7fe fb94 	bl	1b74 <delay>

    // this is according to the hitachi HD44780 datasheet
    // page 45 figure 23
    // Send function set command sequence
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    344c:	2100      	movs	r1, #0
    344e:	2030      	movs	r0, #48	; 0x30
    3450:	f000 f8ea 	bl	3628 <lcd_write>
    delay_ms(5);  				// wait more than 4.1ms
    3454:	4815      	ldr	r0, [pc, #84]	; (34ac <lcd_Init+0xa4>)
    3456:	f7fe fb8d 	bl	1b74 <delay>
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    345a:	2100      	movs	r1, #0
    345c:	2030      	movs	r0, #48	; 0x30
    345e:	f000 f8e3 	bl	3628 <lcd_write>
	delay_us(150);				// wait more than 100us
    3462:	f241 3088 	movw	r0, #5000	; 0x1388
    3466:	f7fe fb85 	bl	1b74 <delay>
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    346a:	2100      	movs	r1, #0
    346c:	2030      	movs	r0, #48	; 0x30
    346e:	f000 f8db 	bl	3628 <lcd_write>
	#if (LCD_CONNECTION == LCD_CONNECTION_PCF8574) || (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_write_init(LCD_FUNCTION_SET | LCD_4BIT_MODE);
	#endif

	// finally, set # lines, font size, etc.
	lcd_command(LCD_FUNCTION_SET | _displayfunction);
    3472:	7820      	ldrb	r0, [r4, #0]
    3474:	f040 0020 	orr.w	r0, r0, #32
    3478:	f7ff ff7e 	bl	3378 <lcd_command>

  	// turn the display on with no cursor or blinking default
  	_displaycontrol = LCD_DISPLAY_ON | LCD_CURSOR_OFF | LCD_BLINK_OFF;
    347c:	4b0c      	ldr	r3, [pc, #48]	; (34b0 <lcd_Init+0xa8>)
    347e:	2204      	movs	r2, #4
    3480:	701a      	strb	r2, [r3, #0]
  	lcd_Display();
    3482:	f7ff ffb5 	bl	33f0 <lcd_Display>

  	// clear it off
  	lcd_Clear();
    3486:	f7ff ff91 	bl	33ac <lcd_Clear>

  	// Initialize to default text direction (for romance languages)
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
    348a:	4b0a      	ldr	r3, [pc, #40]	; (34b4 <lcd_Init+0xac>)
    348c:	2202      	movs	r2, #2
    348e:	701a      	strb	r2, [r3, #0]
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
    3490:	2006      	movs	r0, #6
}
    3492:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
  	lcd_Clear();

  	// Initialize to default text direction (for romance languages)
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
    3496:	f7ff bf6f 	b.w	3378 <lcd_command>
    349a:	bf00      	nop
    349c:	100005f7 	.word	0x100005f7
    34a0:	100005f5 	.word	0x100005f5
    34a4:	100005f0 	.word	0x100005f0
    34a8:	000a2990 	.word	0x000a2990
    34ac:	00028870 	.word	0x00028870
    34b0:	100005f4 	.word	0x100005f4
    34b4:	100005f6 	.word	0x100005f6

Disassembly of section .text.lcd_CreateChar:

000034b8 <lcd_CreateChar>:
// Salva caracteres personalizados nas posições 0 a 7 da memória CGRAM que serão acessadas
//	escrevendo valores de 0 a 7 na DDRAM
// Paramêtros:
//	location: Endereço CGRAM. Valores de 0 a 7
//	charmap: Ponteiro para o vetor de 8 posições que constitui a formação do novo caractere
void lcd_CreateChar(u8 location, u8 charmap[]) {
    34b8:	b570      	push	{r4, r5, r6, lr}
    34ba:	4604      	mov	r4, r0
	u8 addr = lcd_read_command() & 0x7F; // pega o endereço da DDRAM atual
    34bc:	2000      	movs	r0, #0
// Salva caracteres personalizados nas posições 0 a 7 da memória CGRAM que serão acessadas
//	escrevendo valores de 0 a 7 na DDRAM
// Paramêtros:
//	location: Endereço CGRAM. Valores de 0 a 7
//	charmap: Ponteiro para o vetor de 8 posições que constitui a formação do novo caractere
void lcd_CreateChar(u8 location, u8 charmap[]) {
    34be:	460d      	mov	r5, r1
	u8 addr = lcd_read_command() & 0x7F; // pega o endereço da DDRAM atual
    34c0:	f000 f86a 	bl	3598 <lcd_read>
    34c4:	f000 067f 	and.w	r6, r0, #127	; 0x7f

	location &= 0x7; // we only have 8 locations 0-7
  	lcd_command(LCD_SET_CGRAM_ADDR | (location << 3)); // ajusta o endereço deslocando sempre oito bytes porque o buffer é de tamanho 8
    34c8:	f004 0007 	and.w	r0, r4, #7
    34cc:	00c0      	lsls	r0, r0, #3
    34ce:	f040 0040 	orr.w	r0, r0, #64	; 0x40
    34d2:	f7ff ff51 	bl	3378 <lcd_command>
    34d6:	1e6c      	subs	r4, r5, #1
    34d8:	3507      	adds	r5, #7
  	uint i;	for (i=0; i<8; i++) lcd_PutChar(charmap[i]);
    34da:	f814 0f01 	ldrb.w	r0, [r4, #1]!
    34de:	f7ff ff58 	bl	3392 <lcd_PutChar>
    34e2:	42ac      	cmp	r4, r5
    34e4:	d1f9      	bne.n	34da <lcd_CreateChar+0x22>

  	lcd_command(LCD_SET_DDRAM_ADDR | addr); // atualiza o endereço DDRAM e instrui o LCD a trablhar com acesso a DDRAM
    34e6:	f046 0080 	orr.w	r0, r6, #128	; 0x80
}
    34ea:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}

	location &= 0x7; // we only have 8 locations 0-7
  	lcd_command(LCD_SET_CGRAM_ADDR | (location << 3)); // ajusta o endereço deslocando sempre oito bytes porque o buffer é de tamanho 8
  	uint i;	for (i=0; i<8; i++) lcd_PutChar(charmap[i]);

  	lcd_command(LCD_SET_DDRAM_ADDR | addr); // atualiza o endereço DDRAM e instrui o LCD a trablhar com acesso a DDRAM
    34ee:	f7ff bf43 	b.w	3378 <lcd_command>

Disassembly of section .text.lcd_printfInit:

000034f4 <lcd_printfInit>:

#if (LCD_USE_PRINTF == pdON)
#include "stdio_uc.h"
static uint devicePrintf = 0;
u8 _cols;
void lcd_printfInit(uint cols, uint dev) {
    34f4:	460b      	mov	r3, r1
	_cols = cols;
    34f6:	4a04      	ldr	r2, [pc, #16]	; (3508 <lcd_printfInit+0x14>)
    34f8:	7010      	strb	r0, [r2, #0]
	devicePrintf = dev;
    34fa:	4a04      	ldr	r2, [pc, #16]	; (350c <lcd_printfInit+0x18>)
	rprintf_RegisterDev(dev, lcd_PutChar);								// Anexa a função ao printf
    34fc:	b2d8      	uxtb	r0, r3
#include "stdio_uc.h"
static uint devicePrintf = 0;
u8 _cols;
void lcd_printfInit(uint cols, uint dev) {
	_cols = cols;
	devicePrintf = dev;
    34fe:	6011      	str	r1, [r2, #0]
	rprintf_RegisterDev(dev, lcd_PutChar);								// Anexa a função ao printf
    3500:	4903      	ldr	r1, [pc, #12]	; (3510 <lcd_printfInit+0x1c>)
    3502:	f7ff b93f 	b.w	2784 <rprintf_RegisterDev>
    3506:	bf00      	nop
    3508:	100005f8 	.word	0x100005f8
    350c:	10000864 	.word	0x10000864
    3510:	00003393 	.word	0x00003393

Disassembly of section .text.lcd_printf:

00003514 <lcd_printf>:
}

// faz o mesmo que rprintf, porém acrescenta espaços vazios para preencher toda a linha,
//	apagando os caracteres impressos anteriormente
void lcd_printf(const cpchar fmt, ...) {
    3514:	b40f      	push	{r0, r1, r2, r3}
    3516:	b510      	push	{r4, lr}
    3518:	b096      	sub	sp, #88	; 0x58
    351a:	aa18      	add	r2, sp, #96	; 0x60
    351c:	f852 1b04 	ldr.w	r1, [r2], #4
	string s;
	tPrint output;

	output.device = 0;
    3520:	2300      	movs	r3, #0
    3522:	f88d 3014 	strb.w	r3, [sp, #20]
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    3526:	ac06      	add	r4, sp, #24
	output.isSformat = 1;			// Sinaliza que é um sformat
    3528:	2301      	movs	r3, #1

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    352a:	a802      	add	r0, sp, #8
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
	output.isSformat = 1;			// Sinaliza que é um sformat
    352c:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    3530:	9201      	str	r2, [sp, #4]
void lcd_printf(const cpchar fmt, ...) {
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    3532:	9402      	str	r4, [sp, #8]
	output.isSformat = 1;			// Sinaliza que é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    3534:	f7ff f950 	bl	27d8 <doprint>
	va_end(args);					// Desmonta args

	uint len = strlen(s);
    3538:	4620      	mov	r0, r4
    353a:	f000 f953 	bl	37e4 <strlen>
	uint x; for (x=len;x<_cols;x++) s[x]=' ';
    353e:	4b09      	ldr	r3, [pc, #36]	; (3564 <lcd_printf+0x50>)
    3540:	2220      	movs	r2, #32
    3542:	781b      	ldrb	r3, [r3, #0]
    3544:	4298      	cmp	r0, r3
    3546:	d202      	bcs.n	354e <lcd_printf+0x3a>
    3548:	5422      	strb	r2, [r4, r0]
    354a:	3001      	adds	r0, #1
    354c:	e7fa      	b.n	3544 <lcd_printf+0x30>
	rprintf(devicePrintf, "%s", s);
    354e:	4b06      	ldr	r3, [pc, #24]	; (3568 <lcd_printf+0x54>)
    3550:	4622      	mov	r2, r4
    3552:	4906      	ldr	r1, [pc, #24]	; (356c <lcd_printf+0x58>)
    3554:	7818      	ldrb	r0, [r3, #0]
    3556:	f7ff fb01 	bl	2b5c <rprintf>
}
    355a:	b016      	add	sp, #88	; 0x58
    355c:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
    3560:	b004      	add	sp, #16
    3562:	4770      	bx	lr
    3564:	100005f8 	.word	0x100005f8
    3568:	10000864 	.word	0x10000864
    356c:	00003f3d 	.word	0x00003f3d

Disassembly of section .text.lcd_config_ports:

00003570 <lcd_config_ports>:

	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4); // Pinos dos dados como entrada
}
#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
void lcd_config_ports(void)	{
	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como entrada
    3570:	4a08      	ldr	r2, [pc, #32]	; (3594 <lcd_config_ports+0x24>)
    3572:	6813      	ldr	r3, [r2, #0]
    3574:	f423 737f 	bic.w	r3, r3, #1020	; 0x3fc
    3578:	6013      	str	r3, [r2, #0]
	LCD_PORTCTRL_DIR |= (LCD_PIN_RS|LCD_PIN_WR|LCD_PIN_E); // Pinos de controle como saida
    357a:	f852 3c20 	ldr.w	r3, [r2, #-32]
    357e:	f443 0398 	orr.w	r3, r3, #4980736	; 0x4c0000
    3582:	f842 3c20 	str.w	r3, [r2, #-32]
	LCD_PORTCTRL_CLR |= LCD_PIN_E;
    3586:	f852 3c04 	ldr.w	r3, [r2, #-4]
    358a:	f443 0380 	orr.w	r3, r3, #4194304	; 0x400000
    358e:	f842 3c04 	str.w	r3, [r2, #-4]
    3592:	4770      	bx	lr
    3594:	2009c040 	.word	0x2009c040

Disassembly of section .text.lcd_read:

00003598 <lcd_read>:
// 		rs: 0: Sinaliza ler um comando
//			1: Sinaliza ler um dado
u8 lcd_read(u8 rs) {
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
    3598:	4b20      	ldr	r3, [pc, #128]	; (361c <lcd_read+0x84>)
    359a:	f44f 2200 	mov.w	r2, #524288	; 0x80000
//		wr: 1: Sinaliza leitura
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza ler um comando
//			1: Sinaliza ler um dado
u8 lcd_read(u8 rs) {
    359e:	b510      	push	{r4, lr}
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
    35a0:	601a      	str	r2, [r3, #0]
    35a2:	4c1f      	ldr	r4, [pc, #124]	; (3620 <lcd_read+0x88>)
    35a4:	f44f 2280 	mov.w	r2, #262144	; 0x40000
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
    35a8:	b108      	cbz	r0, 35ae <lcd_read+0x16>
    35aa:	601a      	str	r2, [r3, #0]
    35ac:	e000      	b.n	35b0 <lcd_read+0x18>
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
    35ae:	6022      	str	r2, [r4, #0]
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
    35b0:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
	delay_us(LCD_DELAY);
    35b4:	2021      	movs	r0, #33	; 0x21
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
    35b6:	601a      	str	r2, [r3, #0]
	delay_us(LCD_DELAY);
    35b8:	f7fe fadc 	bl	1b74 <delay>

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
    35bc:	4b19      	ldr	r3, [pc, #100]	; (3624 <lcd_read+0x8c>)
    35be:	681a      	ldr	r2, [r3, #0]
    35c0:	f412 7f00 	tst.w	r2, #512	; 0x200
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    35c4:	681a      	ldr	r2, [r3, #0]
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
    35c6:	bf0c      	ite	eq
    35c8:	2000      	moveq	r0, #0
    35ca:	2080      	movne	r0, #128	; 0x80
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    35cc:	05d1      	lsls	r1, r2, #23
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    35ce:	681a      	ldr	r2, [r3, #0]
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    35d0:	bf44      	itt	mi
    35d2:	f040 0040 	orrmi.w	r0, r0, #64	; 0x40
    35d6:	b2c0      	uxtbmi	r0, r0
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    35d8:	0612      	lsls	r2, r2, #24
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    35da:	681a      	ldr	r2, [r3, #0]
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    35dc:	bf48      	it	mi
    35de:	f040 0020 	orrmi.w	r0, r0, #32
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    35e2:	0651      	lsls	r1, r2, #25
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    35e4:	681a      	ldr	r2, [r3, #0]
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    35e6:	bf48      	it	mi
    35e8:	f040 0010 	orrmi.w	r0, r0, #16
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    35ec:	0692      	lsls	r2, r2, #26
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    35ee:	681a      	ldr	r2, [r3, #0]

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    35f0:	bf48      	it	mi
    35f2:	f040 0008 	orrmi.w	r0, r0, #8
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    35f6:	06d1      	lsls	r1, r2, #27
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
    35f8:	681a      	ldr	r2, [r3, #0]
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    35fa:	681b      	ldr	r3, [r3, #0]
	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    35fc:	bf48      	it	mi
    35fe:	f040 0004 	orrmi.w	r0, r0, #4
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
    3602:	0712      	lsls	r2, r2, #28
    3604:	bf48      	it	mi
    3606:	f040 0002 	orrmi.w	r0, r0, #2
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    360a:	075b      	lsls	r3, r3, #29

	LCD_PORTCTRL_CLR = LCD_PIN_E;			// E = 0
    360c:	f44f 0380 	mov.w	r3, #4194304	; 0x400000
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    3610:	bf48      	it	mi
    3612:	f040 0001 	orrmi.w	r0, r0, #1

	LCD_PORTCTRL_CLR = LCD_PIN_E;			// E = 0
    3616:	6023      	str	r3, [r4, #0]

	return value;
}
    3618:	bd10      	pop	{r4, pc}
    361a:	bf00      	nop
    361c:	2009c038 	.word	0x2009c038
    3620:	2009c03c 	.word	0x2009c03c
    3624:	2009c054 	.word	0x2009c054

Disassembly of section .text.lcd_write:

00003628 <lcd_write>:
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    3628:	4b2d      	ldr	r3, [pc, #180]	; (36e0 <lcd_write+0xb8>)
//		wr: 0: Sinaliza escrita
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
    362a:	b570      	push	{r4, r5, r6, lr}
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    362c:	681a      	ldr	r2, [r3, #0]
	LCD_PORTCTRL_CLR = LCD_PIN_WR;			// WR = 0;
    362e:	4c2d      	ldr	r4, [pc, #180]	; (36e4 <lcd_write+0xbc>)
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    3630:	f442 727f 	orr.w	r2, r2, #1020	; 0x3fc
    3634:	601a      	str	r2, [r3, #0]
	LCD_PORTCTRL_CLR = LCD_PIN_WR;			// WR = 0;
    3636:	f44f 2200 	mov.w	r2, #524288	; 0x80000
    363a:	6022      	str	r2, [r4, #0]
    363c:	461d      	mov	r5, r3
    363e:	f44f 2280 	mov.w	r2, #262144	; 0x40000
    3642:	3b08      	subs	r3, #8

	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
    3644:	b109      	cbz	r1, 364a <lcd_write+0x22>
    3646:	601a      	str	r2, [r3, #0]
    3648:	e000      	b.n	364c <lcd_write+0x24>
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
    364a:	6022      	str	r2, [r4, #0]

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
    364c:	f010 0f80 	tst.w	r0, #128	; 0x80
    3650:	bf14      	ite	ne
    3652:	4925      	ldrne	r1, [pc, #148]	; (36e8 <lcd_write+0xc0>)
    3654:	4925      	ldreq	r1, [pc, #148]	; (36ec <lcd_write+0xc4>)
    3656:	f44f 7200 	mov.w	r2, #512	; 0x200
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    365a:	f010 0f40 	tst.w	r0, #64	; 0x40

	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
    365e:	600a      	str	r2, [r1, #0]
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    3660:	bf14      	ite	ne
    3662:	4921      	ldrne	r1, [pc, #132]	; (36e8 <lcd_write+0xc0>)
    3664:	4921      	ldreq	r1, [pc, #132]	; (36ec <lcd_write+0xc4>)
    3666:	f44f 7280 	mov.w	r2, #256	; 0x100
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    366a:	f010 0f20 	tst.w	r0, #32
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    366e:	600a      	str	r2, [r1, #0]
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    3670:	bf14      	ite	ne
    3672:	491d      	ldrne	r1, [pc, #116]	; (36e8 <lcd_write+0xc0>)
    3674:	491d      	ldreq	r1, [pc, #116]	; (36ec <lcd_write+0xc4>)
    3676:	2280      	movs	r2, #128	; 0x80
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    3678:	f010 0f10 	tst.w	r0, #16
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    367c:	600a      	str	r2, [r1, #0]
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    367e:	bf14      	ite	ne
    3680:	4919      	ldrne	r1, [pc, #100]	; (36e8 <lcd_write+0xc0>)
    3682:	491a      	ldreq	r1, [pc, #104]	; (36ec <lcd_write+0xc4>)
    3684:	2240      	movs	r2, #64	; 0x40
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    3686:	f010 0f08 	tst.w	r0, #8

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    368a:	600a      	str	r2, [r1, #0]
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    368c:	bf14      	ite	ne
    368e:	4916      	ldrne	r1, [pc, #88]	; (36e8 <lcd_write+0xc0>)
    3690:	4916      	ldreq	r1, [pc, #88]	; (36ec <lcd_write+0xc4>)
    3692:	2220      	movs	r2, #32
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    3694:	f010 0f04 	tst.w	r0, #4
	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    3698:	600a      	str	r2, [r1, #0]
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    369a:	bf14      	ite	ne
    369c:	4912      	ldrne	r1, [pc, #72]	; (36e8 <lcd_write+0xc0>)
    369e:	4913      	ldreq	r1, [pc, #76]	; (36ec <lcd_write+0xc4>)
    36a0:	2210      	movs	r2, #16
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    36a2:	f010 0f02 	tst.w	r0, #2
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    36a6:	600a      	str	r2, [r1, #0]
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    36a8:	bf14      	ite	ne
    36aa:	490f      	ldrne	r1, [pc, #60]	; (36e8 <lcd_write+0xc0>)
    36ac:	490f      	ldreq	r1, [pc, #60]	; (36ec <lcd_write+0xc4>)
    36ae:	2208      	movs	r2, #8
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    36b0:	f010 0f01 	tst.w	r0, #1
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    36b4:	600a      	str	r2, [r1, #0]
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    36b6:	bf14      	ite	ne
    36b8:	490b      	ldrne	r1, [pc, #44]	; (36e8 <lcd_write+0xc0>)
    36ba:	490c      	ldreq	r1, [pc, #48]	; (36ec <lcd_write+0xc4>)
    36bc:	2204      	movs	r2, #4

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
    36be:	f44f 0680 	mov.w	r6, #4194304	; 0x400000
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    36c2:	600a      	str	r2, [r1, #0]

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
	delay_us(LCD_DELAY);
    36c4:	2021      	movs	r0, #33	; 0x21
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
    36c6:	601e      	str	r6, [r3, #0]
	delay_us(LCD_DELAY);
    36c8:	f7fe fa54 	bl	1b74 <delay>
	LCD_PORTCTRL_CLR = LCD_PIN_E;	// E = 0
    36cc:	6026      	str	r6, [r4, #0]
	delay_us(LCD_DELAY);
    36ce:	2021      	movs	r0, #33	; 0x21
    36d0:	f7fe fa50 	bl	1b74 <delay>
	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como entrada
    36d4:	682b      	ldr	r3, [r5, #0]
    36d6:	f423 737f 	bic.w	r3, r3, #1020	; 0x3fc
    36da:	602b      	str	r3, [r5, #0]
    36dc:	bd70      	pop	{r4, r5, r6, pc}
    36de:	bf00      	nop
    36e0:	2009c040 	.word	0x2009c040
    36e4:	2009c03c 	.word	0x2009c03c
    36e8:	2009c058 	.word	0x2009c058
    36ec:	2009c05c 	.word	0x2009c05c

Disassembly of section .text.__get_current_locale:

000036f0 <__get_current_locale>:
    36f0:	4a03      	ldr	r2, [pc, #12]	; (3700 <__get_current_locale+0x10>)
    36f2:	4b04      	ldr	r3, [pc, #16]	; (3704 <__get_current_locale+0x14>)
    36f4:	6812      	ldr	r2, [r2, #0]
    36f6:	6b50      	ldr	r0, [r2, #52]	; 0x34
    36f8:	2800      	cmp	r0, #0
    36fa:	bf08      	it	eq
    36fc:	4618      	moveq	r0, r3
    36fe:	4770      	bx	lr
    3700:	100005d0 	.word	0x100005d0
    3704:	10000038 	.word	0x10000038

Disassembly of section .text.__locale_ctype_ptr:

00003708 <__locale_ctype_ptr>:
    3708:	b508      	push	{r3, lr}
    370a:	4b03      	ldr	r3, [pc, #12]	; (3718 <__locale_ctype_ptr+0x10>)
    370c:	6818      	ldr	r0, [r3, #0]
    370e:	f7ff ffef 	bl	36f0 <__get_current_locale>
    3712:	f8d0 00ec 	ldr.w	r0, [r0, #236]	; 0xec
    3716:	bd08      	pop	{r3, pc}
    3718:	100005d0 	.word	0x100005d0

Disassembly of section .text.__ascii_mbtowc:

0000371c <__ascii_mbtowc>:
    371c:	b082      	sub	sp, #8
    371e:	b149      	cbz	r1, 3734 <__ascii_mbtowc+0x18>
    3720:	b15a      	cbz	r2, 373a <__ascii_mbtowc+0x1e>
    3722:	b16b      	cbz	r3, 3740 <__ascii_mbtowc+0x24>
    3724:	7813      	ldrb	r3, [r2, #0]
    3726:	600b      	str	r3, [r1, #0]
    3728:	7812      	ldrb	r2, [r2, #0]
    372a:	1c10      	adds	r0, r2, #0
    372c:	bf18      	it	ne
    372e:	2001      	movne	r0, #1
    3730:	b002      	add	sp, #8
    3732:	4770      	bx	lr
    3734:	a901      	add	r1, sp, #4
    3736:	2a00      	cmp	r2, #0
    3738:	d1f3      	bne.n	3722 <__ascii_mbtowc+0x6>
    373a:	4610      	mov	r0, r2
    373c:	b002      	add	sp, #8
    373e:	4770      	bx	lr
    3740:	f06f 0001 	mvn.w	r0, #1
    3744:	e7f4      	b.n	3730 <__ascii_mbtowc+0x14>
    3746:	bf00      	nop

Disassembly of section .text.memset:

00003748 <memset>:
    3748:	b470      	push	{r4, r5, r6}
    374a:	0784      	lsls	r4, r0, #30
    374c:	d046      	beq.n	37dc <memset+0x94>
    374e:	1e54      	subs	r4, r2, #1
    3750:	2a00      	cmp	r2, #0
    3752:	d041      	beq.n	37d8 <memset+0x90>
    3754:	b2cd      	uxtb	r5, r1
    3756:	4603      	mov	r3, r0
    3758:	e002      	b.n	3760 <memset+0x18>
    375a:	1e62      	subs	r2, r4, #1
    375c:	b3e4      	cbz	r4, 37d8 <memset+0x90>
    375e:	4614      	mov	r4, r2
    3760:	f803 5b01 	strb.w	r5, [r3], #1
    3764:	079a      	lsls	r2, r3, #30
    3766:	d1f8      	bne.n	375a <memset+0x12>
    3768:	2c03      	cmp	r4, #3
    376a:	d92e      	bls.n	37ca <memset+0x82>
    376c:	b2cd      	uxtb	r5, r1
    376e:	ea45 2505 	orr.w	r5, r5, r5, lsl #8
    3772:	2c0f      	cmp	r4, #15
    3774:	ea45 4505 	orr.w	r5, r5, r5, lsl #16
    3778:	d919      	bls.n	37ae <memset+0x66>
    377a:	4626      	mov	r6, r4
    377c:	f103 0210 	add.w	r2, r3, #16
    3780:	3e10      	subs	r6, #16
    3782:	2e0f      	cmp	r6, #15
    3784:	f842 5c10 	str.w	r5, [r2, #-16]
    3788:	f842 5c0c 	str.w	r5, [r2, #-12]
    378c:	f842 5c08 	str.w	r5, [r2, #-8]
    3790:	f842 5c04 	str.w	r5, [r2, #-4]
    3794:	f102 0210 	add.w	r2, r2, #16
    3798:	d8f2      	bhi.n	3780 <memset+0x38>
    379a:	f1a4 0210 	sub.w	r2, r4, #16
    379e:	f022 020f 	bic.w	r2, r2, #15
    37a2:	f004 040f 	and.w	r4, r4, #15
    37a6:	3210      	adds	r2, #16
    37a8:	2c03      	cmp	r4, #3
    37aa:	4413      	add	r3, r2
    37ac:	d90d      	bls.n	37ca <memset+0x82>
    37ae:	461e      	mov	r6, r3
    37b0:	4622      	mov	r2, r4
    37b2:	3a04      	subs	r2, #4
    37b4:	2a03      	cmp	r2, #3
    37b6:	f846 5b04 	str.w	r5, [r6], #4
    37ba:	d8fa      	bhi.n	37b2 <memset+0x6a>
    37bc:	1f22      	subs	r2, r4, #4
    37be:	f022 0203 	bic.w	r2, r2, #3
    37c2:	3204      	adds	r2, #4
    37c4:	4413      	add	r3, r2
    37c6:	f004 0403 	and.w	r4, r4, #3
    37ca:	b12c      	cbz	r4, 37d8 <memset+0x90>
    37cc:	b2c9      	uxtb	r1, r1
    37ce:	441c      	add	r4, r3
    37d0:	f803 1b01 	strb.w	r1, [r3], #1
    37d4:	42a3      	cmp	r3, r4
    37d6:	d1fb      	bne.n	37d0 <memset+0x88>
    37d8:	bc70      	pop	{r4, r5, r6}
    37da:	4770      	bx	lr
    37dc:	4614      	mov	r4, r2
    37de:	4603      	mov	r3, r0
    37e0:	e7c2      	b.n	3768 <memset+0x20>
    37e2:	bf00      	nop

Disassembly of section .text.strlen:

000037e4 <strlen>:
    37e4:	f020 0103 	bic.w	r1, r0, #3
    37e8:	f010 0003 	ands.w	r0, r0, #3
    37ec:	f1c0 0000 	rsb	r0, r0, #0
    37f0:	f851 3b04 	ldr.w	r3, [r1], #4
    37f4:	f100 0c04 	add.w	ip, r0, #4
    37f8:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    37fc:	f06f 0200 	mvn.w	r2, #0
    3800:	bf1c      	itt	ne
    3802:	fa22 f20c 	lsrne.w	r2, r2, ip
    3806:	4313      	orrne	r3, r2
    3808:	f04f 0c01 	mov.w	ip, #1
    380c:	ea4c 2c0c 	orr.w	ip, ip, ip, lsl #8
    3810:	ea4c 4c0c 	orr.w	ip, ip, ip, lsl #16
    3814:	eba3 020c 	sub.w	r2, r3, ip
    3818:	ea22 0203 	bic.w	r2, r2, r3
    381c:	ea12 12cc 	ands.w	r2, r2, ip, lsl #7
    3820:	bf04      	itt	eq
    3822:	f851 3b04 	ldreq.w	r3, [r1], #4
    3826:	3004      	addeq	r0, #4
    3828:	d0f4      	beq.n	3814 <strlen+0x30>
    382a:	f1c2 0100 	rsb	r1, r2, #0
    382e:	ea02 0201 	and.w	r2, r2, r1
    3832:	fab2 f282 	clz	r2, r2
    3836:	f1c2 021f 	rsb	r2, r2, #31
    383a:	eb00 00d2 	add.w	r0, r0, r2, lsr #3
    383e:	4770      	bx	lr

Disassembly of section .text.__ascii_wctomb:

00003840 <__ascii_wctomb>:
    3840:	b121      	cbz	r1, 384c <__ascii_wctomb+0xc>
    3842:	2aff      	cmp	r2, #255	; 0xff
    3844:	d804      	bhi.n	3850 <__ascii_wctomb+0x10>
    3846:	700a      	strb	r2, [r1, #0]
    3848:	2001      	movs	r0, #1
    384a:	4770      	bx	lr
    384c:	4608      	mov	r0, r1
    384e:	4770      	bx	lr
    3850:	238a      	movs	r3, #138	; 0x8a
    3852:	6003      	str	r3, [r0, #0]
    3854:	f04f 30ff 	mov.w	r0, #4294967295
    3858:	4770      	bx	lr
    385a:	bf00      	nop
